vtkRenderer.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkRenderer_h
#define vtkRenderer_h

#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkViewport.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO

#include "vtkActorCollection.h" // Needed for access in inline members
#include "vtkMatrix3x3.h"
#include "vtkVolumeCollection.h" // Needed for access in inline members

#include <array> // To store matrices

VTK_ABI_NAMESPACE_BEGIN
class vtkFXAAOptions;
class vtkRenderWindow;
class vtkVolume;
class vtkCuller;
class vtkActor;
class vtkActor2D;
class vtkCamera;
class vtkFrameBufferObjectBase;
class vtkInformation;
class vtkLightCollection;
class vtkCullerCollection;
class vtkLight;
class vtkHardwareSelector;
class vtkRendererDelegate;
class vtkRenderPass;
class vtkTexture;

class vtkRecti;
class vtkVector3d;

class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkRenderer : public vtkViewport
{
public:
  vtkTypeMacro(vtkRenderer, vtkViewport);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkRenderer* New();


  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void AddActor(vtkProp* p);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void AddVolume(vtkProp* p);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void RemoveActor(vtkProp* p);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void RemoveVolume(vtkProp* p);

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void AddLight(vtkLight*);

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void RemoveLight(vtkLight*);

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void RemoveAllLights();

  vtkLightCollection* GetLights();

  void SetLightCollection(vtkLightCollection* lights);

  void CreateLight();

  virtual vtkLight* MakeLight();


  vtkGetMacro(TwoSidedLighting, vtkTypeBool);
  vtkSetMacro(TwoSidedLighting, vtkTypeBool);
  vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);


  vtkSetMacro(LightFollowCamera, vtkTypeBool);
  vtkGetMacro(LightFollowCamera, vtkTypeBool);
  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);


  vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
  vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
  vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);

  virtual vtkTypeBool UpdateLightsGeometryToFollowCamera();

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  vtkVolumeCollection* GetVolumes();

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  vtkActorCollection* GetActors();

  void SetActiveCamera(vtkCamera*);

  vtkCamera* GetActiveCamera();

  virtual vtkCamera* MakeCamera();


  vtkSetMacro(Erase, vtkTypeBool);
  vtkGetMacro(Erase, vtkTypeBool);
  vtkBooleanMacro(Erase, vtkTypeBool);


  vtkSetMacro(Draw, vtkTypeBool);
  vtkGetMacro(Draw, vtkTypeBool);
  vtkBooleanMacro(Draw, vtkTypeBool);

  int CaptureGL2PSSpecialProp(vtkProp*);

  void SetGL2PSSpecialPropCollection(vtkPropCollection*);

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void AddCuller(vtkCuller*);

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void RemoveCuller(vtkCuller*);

  vtkCullerCollection* GetCullers();


  vtkSetVector3Macro(Ambient, double);
  vtkGetVectorMacro(Ambient, double, 3);


  vtkSetMacro(AllocatedRenderTime, double);
  virtual double GetAllocatedRenderTime();

  virtual double GetTimeFactor();

  virtual void Render();

  virtual void DeviceRender() {}

  virtual void DeviceRenderOpaqueGeometry(vtkFrameBufferObjectBase* fbo = nullptr);

  virtual void DeviceRenderTranslucentPolygonalGeometry(vtkFrameBufferObjectBase* fbo = nullptr);

  virtual void ClearLights() {}

  virtual void Clear() {}

  int VisibleActorCount();

  int VisibleVolumeCount();

  void ComputeVisiblePropBounds(double bounds[6]);

  double* ComputeVisiblePropBounds() VTK_SIZEHINT(6);

  virtual void ResetCameraClippingRange();


  virtual void ResetCameraClippingRange(const double bounds[6]);
  virtual void ResetCameraClippingRange(
    double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);


  vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
  vtkGetMacro(NearClippingPlaneTolerance, double);


  vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
  vtkGetMacro(ClippingRangeExpansion, double);

  virtual bool ResetCamera();

  virtual void ResetCamera(const double bounds[6]);

  virtual void ResetCamera(
    double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);

  virtual bool ResetCameraScreenSpace(double offsetRatio = 0.9);

  virtual void ResetCameraScreenSpace(const double bounds[6], double offsetRatio = 0.9);

  using vtkViewport::DisplayToWorld;

  vtkVector3d DisplayToWorld(const vtkVector3d& display);

  void ZoomToBoxUsingViewAngle(const vtkRecti& box, double offsetRatio = 1.0);

  virtual void ResetCameraScreenSpace(double xmin, double xmax, double ymin, double ymax,
    double zmin, double zmax, double offsetRatio = 0.9);


  void SetRenderWindow(vtkRenderWindow*);
  vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
  vtkWindow* GetVTKWindow() override;


  vtkSetMacro(BackingStore, vtkTypeBool);
  vtkGetMacro(BackingStore, vtkTypeBool);
  vtkBooleanMacro(BackingStore, vtkTypeBool);


  vtkSetMacro(Interactive, vtkTypeBool);
  vtkGetMacro(Interactive, vtkTypeBool);
  vtkBooleanMacro(Interactive, vtkTypeBool);


  virtual void SetLayer(int layer);
  vtkGetMacro(Layer, int);


  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);


  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);

  vtkTypeBool Transparent();

  void WorldToView() override;


  void ViewToWorld() override;
  void ViewToWorld(double& wx, double& wy, double& wz) override;

  void WorldToView(double& wx, double& wy, double& wz) override;


  void WorldToPose(double& wx, double& wy, double& wz) override;
  void PoseToWorld(double& wx, double& wy, double& wz) override;
  void ViewToPose(double& wx, double& wy, double& wz) override;
  void PoseToView(double& wx, double& wy, double& wz) override;

  double GetZ(int x, int y);


  vtkSetMacro(SafeGetZ, bool);
  vtkGetMacro(SafeGetZ, bool);
  vtkBooleanMacro(SafeGetZ, bool);

  vtkMTimeType GetMTime() override;


  vtkGetMacro(LastRenderTimeInSeconds, double);


  vtkGetMacro(NumberOfPropsRendered, int);


  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
  {
    return this->PickProp(selectionX, selectionY, selectionX, selectionY);
  }
  vtkAssemblyPath* PickProp(
    double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;


  vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
    vtkSmartPointer<vtkSelection> selection) override
  {
    return this->PickProp(
      selectionX, selectionY, selectionX, selectionY, fieldAssociation, selection);
  }
  vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
    double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) override;

  virtual void StereoMidpoint() {}

  double GetTiledAspectRatio();

  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }


  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);

  vtkSetMacro(UseDepthPeelingForVolumes, bool);
  vtkGetMacro(UseDepthPeelingForVolumes, bool);
  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);


  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
  vtkGetMacro(OcclusionRatio, double);


  vtkSetMacro(MaximumNumberOfPeels, int);
  vtkGetMacro(MaximumNumberOfPeels, int);


  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);


  vtkSetMacro(UseSSAO, bool);
  vtkGetMacro(UseSSAO, bool);
  vtkBooleanMacro(UseSSAO, bool);


  vtkSetMacro(SSAORadius, double);
  vtkGetMacro(SSAORadius, double);


  vtkSetMacro(SSAOBias, double);
  vtkGetMacro(SSAOBias, double);


  vtkSetMacro(SSAOKernelSize, unsigned int);
  vtkGetMacro(SSAOKernelSize, unsigned int);


  vtkSetMacro(SSAOBlur, bool);
  vtkGetMacro(SSAOBlur, bool);
  vtkBooleanMacro(SSAOBlur, bool);


  void SetDelegate(vtkRendererDelegate* d);
  vtkGetObjectMacro(Delegate, vtkRendererDelegate);


  vtkGetObjectMacro(Selector, vtkHardwareSelector);


  virtual void SetLeftBackgroundTexture(vtkTexture*);
  vtkTexture* GetLeftBackgroundTexture();
  virtual void SetBackgroundTexture(vtkTexture*);
  vtkGetObjectMacro(BackgroundTexture, vtkTexture);


  virtual void SetRightBackgroundTexture(vtkTexture*);
  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);


  vtkSetMacro(TexturedBackground, bool);
  vtkGetMacro(TexturedBackground, bool);
  vtkBooleanMacro(TexturedBackground, bool);

  // method to release graphics resources in any derived renderers.
  virtual void ReleaseGraphicsResources(vtkWindow*);


  vtkSetMacro(UseFXAA, bool);
  vtkGetMacro(UseFXAA, bool);
  vtkBooleanMacro(UseFXAA, bool);


  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
  virtual void SetFXAAOptions(vtkFXAAOptions*);


  vtkSetMacro(UseShadows, vtkTypeBool);
  vtkGetMacro(UseShadows, vtkTypeBool);
  vtkBooleanMacro(UseShadows, vtkTypeBool);


  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);

  // Set/Get a custom render pass.
  // Initial value is NULL.
  void SetPass(vtkRenderPass* p);
  vtkGetObjectMacro(Pass, vtkRenderPass);


  vtkGetObjectMacro(Information, vtkInformation);
  virtual void SetInformation(vtkInformation*);


  vtkSetMacro(UseImageBasedLighting, bool);
  vtkGetMacro(UseImageBasedLighting, bool);
  vtkBooleanMacro(UseImageBasedLighting, bool);


  VTK_MARSHALGETTER(EnvironmentTextureProperty)
  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
  VTK_MARSHALSETTER(EnvironmentTextureProperty)
  void SetEnvironmentTextureProperty(vtkTexture* texture) { this->SetEnvironmentTexture(texture); }
  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);


  virtual double* GetEnvironmentUp();
  virtual void GetEnvironmentUp(double& vectorUpX, double& vectorUpY, double& vectorUpZ);
  virtual void GetEnvironmentUp(double vectorUp[3]);
  virtual void SetEnvironmentUp(double vectorUpX, double vectorUpY, double vectorUpZ);
  virtual void SetEnvironmentUp(double vectorUp[3]);


  virtual double* GetEnvironmentRight();
  virtual void GetEnvironmentRight(
    double& vectorRightX, double& vectorRightY, double& vectorRightZ);
  virtual void GetEnvironmentRight(double vectorRight[3]);
  virtual void SetEnvironmentRight(double vectorRightX, double vectorRightY, double vectorRightZ);
  virtual void SetEnvironmentRight(double vectorRight[3]);


  vtkGetSmartPointerMacro(EnvironmentRotationMatrix, vtkMatrix3x3);
  void SetEnvironmentRotationMatrix(vtkMatrix3x3* matrix);


  vtkSetMacro(SkyboxBlurEnabled, bool);
  vtkGetMacro(SkyboxBlurEnabled, bool);
  vtkBooleanMacro(SkyboxBlurEnabled, bool);


  vtkSetMacro(SkyboxBlurRadius, float);
  vtkGetMacro(SkyboxBlurRadius, float);


  vtkSetMacro(UseOIT, bool);
  vtkGetMacro(UseOIT, bool);
  vtkBooleanMacro(UseOIT, bool);

protected:
  vtkRenderer();
  ~vtkRenderer() override;

  // internal method to expand bounding box to consider model transform
  // matrix or model view transform matrix based on whether or not deering
  // frustum is used. 'bounds' buffer is mutated to the expanded box.
  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);

  vtkCamera* ActiveCamera;
  vtkLight* CreatedLight;

  vtkLightCollection* Lights;
  vtkCullerCollection* Cullers;

  vtkActorCollection* Actors;
  vtkVolumeCollection* Volumes;

  double Ambient[3];
  vtkRenderWindow* RenderWindow;
  double AllocatedRenderTime;
  double TimeFactor;
  vtkTypeBool TwoSidedLighting;
  vtkTypeBool AutomaticLightCreation;
  vtkTypeBool BackingStore;
  unsigned char* BackingImage;
  int BackingStoreSize[2];
  vtkTimeStamp RenderTime;

  double LastRenderTimeInSeconds;

  vtkTypeBool LightFollowCamera;

  // Allocate the time for each prop
  void AllocateTime();

  // Internal variables indicating the number of props
  // that have been or will be rendered in each category.
  int NumberOfPropsRendered;

  // A temporary list of props used for culling, and traversal
  // of all props when rendering
  std::vector<vtkProp*> PropArray;
  vtkProp* BackgroundProp = nullptr;

  // Indicates if the renderer should receive events from an interactor.
  // Typically only used in conjunction with transparent renderers.
  vtkTypeBool Interactive;

  // Shows what layer this renderer belongs to.  Only of interested when
  // there are layered renderers.
  int Layer;
  vtkTypeBool PreserveColorBuffer;
  vtkTypeBool PreserveDepthBuffer;

  // Holds the result of ComputeVisiblePropBounds so that it is visible from
  // wrapped languages
  double ComputedVisiblePropBounds[6];

  double NearClippingPlaneTolerance;

  double ClippingRangeExpansion;

  vtkTypeBool Erase;

  vtkTypeBool Draw;

  vtkPropCollection* GL2PSSpecialPropCollection;

  const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();

  const std::array<double, 16>& GetProjectionTransformationMatrix();

  const std::array<double, 16>& GetViewTransformMatrix();

  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);

  virtual int UpdateTranslucentPolygonalGeometry();

  virtual int UpdateOpaquePolygonalGeometry();

  virtual int UpdateCamera();

  virtual vtkTypeBool UpdateLightGeometry();

  virtual int UpdateLights() { return 0; }

  vtkCamera* GetActiveCameraAndResetIfCreated();

  bool UseFXAA;

  vtkFXAAOptions* FXAAOptions;

  vtkTypeBool UseShadows;

  vtkTypeBool UseHiddenLineRemoval;

  vtkTypeBool UseDepthPeeling;

  bool UseDepthPeelingForVolumes;

  double OcclusionRatio;

  int MaximumNumberOfPeels;

  bool UseSSAO = false;
  double SSAORadius = 0.5;
  double SSAOBias = 0.01;
  unsigned int SSAOKernelSize = 32;
  bool SSAOBlur = false;

  bool UseOIT = true;

  vtkTypeBool LastRenderingUsedDepthPeeling;

  // HARDWARE SELECTION ----------------------------------------
  friend class vtkHardwareSelector;

  void SetSelector(vtkHardwareSelector* selector)
  {
    this->Selector = selector;
    this->Modified();
  }

  // End Ivars for visible cell selecting.
  vtkHardwareSelector* Selector;

  //---------------------------------------------------------------
  friend class vtkRendererDelegate;
  vtkRendererDelegate* Delegate;

  bool TexturedBackground;
  vtkTexture* BackgroundTexture;
  vtkTexture* RightBackgroundTexture;

  friend class vtkRenderPass;
  vtkRenderPass* Pass;

  // Arbitrary extra information associated with this renderer
  vtkInformation* Information;

  bool UseImageBasedLighting;
  vtkTexture* EnvironmentTexture;

private:
  void ComputeRotationMatrixForwardVector();

  std::array<double, 16> CompositeProjectionTransformationMatrix;

  double LastCompositeProjectionTransformationMatrixTiledAspectRatio;

  vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;

  std::array<double, 16> ProjectionTransformationMatrix;

  double LastProjectionTransformationMatrixTiledAspectRatio;

  vtkMTimeType LastProjectionTransformationMatrixCameraModified;

  std::array<double, 16> ViewTransformMatrix;

  vtkMTimeType LastViewTransformCameraModified;

  bool SafeGetZ = false;

  vtkSmartPointer<vtkMatrix3x3> EnvironmentRotationMatrix;


  bool SkyboxBlurEnabled = false;
  float SkyboxBlurRadius = 20.0f;

  double EnvironmentUp[3] = { 0.0, 1.0, 0.0 };
  double EnvironmentRight[3] = { 1.0, 0.0, 0.0 };

  vtkRenderer(const vtkRenderer&) = delete;
  void operator=(const vtkRenderer&) = delete;
};

inline vtkLightCollection* vtkRenderer::GetLights()
{
  return this->Lights;
}

inline vtkCullerCollection* vtkRenderer::GetCullers()
{
  return this->Cullers;
}

VTK_ABI_NAMESPACE_END
#endif