vtkParallelRenderManager.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright 2003 Sandia Corporation
// SPDX-License-Identifier: LicenseRef-BSD-3-Clause-Sandia-USGov
#ifndef vtkParallelRenderManager_h
#define vtkParallelRenderManager_h
 
#include "vtkObject.h"
#include "vtkRenderingParallelModule.h" // For export macro
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDoubleArray;
class vtkMultiProcessController;
class vtkMultiProcessStream;
class vtkRenderer;
class vtkRendererCollection;
class vtkRenderWindow;
class vtkTimerLog;
class vtkUnsignedCharArray;
 
class VTKRENDERINGPARALLEL_EXPORT vtkParallelRenderManager : public vtkObject
{
public:
  vtkTypeMacro(vtkParallelRenderManager, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  virtual vtkRenderWindow* MakeRenderWindow();
 
  virtual vtkRenderer* MakeRenderer();
 
 
  vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
  virtual void SetRenderWindow(vtkRenderWindow* renWin);
 
 
  vtkGetObjectMacro(Controller, vtkMultiProcessController);
  virtual void SetController(vtkMultiProcessController* controller);
 
  virtual void InitializePieces();
 
  virtual void InitializeOffScreen();
 
  virtual void StartInteractor();
 
  virtual void StartServices();
 
  virtual void StopServices();
 
 
  virtual void StartRender();
  virtual void EndRender();
  virtual void SatelliteStartRender();
  virtual void SatelliteEndRender();
  virtual void RenderRMI();
  virtual void ResetCamera(vtkRenderer* ren);
  virtual void ResetCameraClippingRange(vtkRenderer* ren);
  virtual void ComputeVisiblePropBoundsRMI(int renderId);
 
  virtual void InitializeRMIs();
 
  virtual void ResetAllCameras();
 
  virtual void ComputeVisiblePropBounds(vtkRenderer* ren, double bounds[6]);
 
 
  vtkSetMacro(ParallelRendering, int);
  vtkGetMacro(ParallelRendering, int);
  vtkBooleanMacro(ParallelRendering, int);
 
 
  vtkSetMacro(RenderEventPropagation, int);
  vtkGetMacro(RenderEventPropagation, int);
  vtkBooleanMacro(RenderEventPropagation, int);
 
  static void SetDefaultRenderEventPropagation(bool val)
  {
    vtkParallelRenderManager::DefaultRenderEventPropagation = val;
  }
  static bool GetDefaultRenderEventPropagation()
  {
    return vtkParallelRenderManager::DefaultRenderEventPropagation;
  }
 
 
  vtkSetMacro(UseCompositing, int);
  vtkGetMacro(UseCompositing, int);
  vtkBooleanMacro(UseCompositing, int);
 
 
  virtual void SetImageReductionFactor(double factor);
  vtkGetMacro(ImageReductionFactor, double);
 
  vtkSetMacro(MaxImageReductionFactor, double);
  vtkGetMacro(MaxImageReductionFactor, double);
 
  virtual void SetImageReductionFactorForUpdateRate(double DesiredUpdateRate);
 
 
  vtkSetMacro(AutoImageReductionFactor, int);
  vtkGetMacro(AutoImageReductionFactor, int);
  vtkBooleanMacro(AutoImageReductionFactor, int);
 
 
  vtkGetMacro(RenderTime, double);
  vtkGetMacro(ImageProcessingTime, double);
 
 
  vtkGetMacro(SyncRenderWindowRenderers, int);
  vtkSetMacro(SyncRenderWindowRenderers, int);
  vtkBooleanMacro(SyncRenderWindowRenderers, int);
  virtual void AddRenderer(vtkRenderer*);
  virtual void RemoveRenderer(vtkRenderer*);
  virtual void RemoveAllRenderers();
 
 
  vtkSetMacro(WriteBackImages, int);
  vtkGetMacro(WriteBackImages, int);
  vtkBooleanMacro(WriteBackImages, int);
 
 
  vtkSetMacro(MagnifyImages, int);
  vtkGetMacro(MagnifyImages, int);
  vtkBooleanMacro(MagnifyImages, int);
 
  enum
  {
    NEAREST,
    LINEAR
  };
 
 
  virtual void SetMagnifyImageMethod(int method);
  vtkGetMacro(MagnifyImageMethod, int);
  void SetMagnifyImageMethodToNearest() { this->SetMagnifyImageMethod(NEAREST); }
  void SetMagnifyImageMethodToLinear() { this->SetMagnifyImageMethod(LINEAR); }
 
 
  virtual void MagnifyImage(vtkUnsignedCharArray* fullImage, const int fullImageSize[2],
    vtkUnsignedCharArray* reducedImage, const int reducedImageSize[2],
    const int fullImageViewport[4] = nullptr, const int reducedImageViewport[4] = nullptr);
  static void MagnifyImageNearest(vtkUnsignedCharArray* fullImage, const int fullImageSize[2],
    vtkUnsignedCharArray* reducedImage, const int reducedImageSize[2],
    const int fullImageViewport[4] = nullptr, const int reducedImageViewport[4] = nullptr);
  static void MagnifyImageLinear(vtkUnsignedCharArray* fullImage, const int fullImageSize[2],
    vtkUnsignedCharArray* reducedImage, const int reducedImageSize[2],
    const int fullImageViewport[4] = nullptr, const int reducedImageViewport[4] = nullptr);
 
 
  virtual void GetPixelData(vtkUnsignedCharArray* data);
  virtual void GetPixelData(int x1, int y1, int x2, int y2, vtkUnsignedCharArray* data);
 
 
  virtual void GetReducedPixelData(vtkUnsignedCharArray* data);
  virtual void GetReducedPixelData(int x1, int y1, int x2, int y2, vtkUnsignedCharArray* data);
 
 
  vtkGetVector2Macro(FullImageSize, int);
 
  vtkGetVector2Macro(ReducedImageSize, int);
 
  void TileWindows(int xsize, int ysize, int nColumns);
 
 
  vtkSetMacro(UseRGBA, int);
  vtkGetMacro(UseRGBA, int);
 
 
  vtkSetMacro(ForceRenderWindowSize, int);
  vtkGetMacro(ForceRenderWindowSize, int);
 
 
  vtkSetVector2Macro(ForcedRenderWindowSize, int);
  vtkGetVector2Macro(ForcedRenderWindowSize, int);
 
  enum Tags
  {
    RENDER_RMI_TAG = 34532,
    COMPUTE_VISIBLE_PROP_BOUNDS_RMI_TAG = 54636,
    WIN_INFO_TAG = 87834,
    REN_INFO_TAG = 87836,
    LIGHT_INFO_TAG = 87838,
    REN_ID_TAG = 58794,
    BOUNDS_TAG = 23543
  };
 
  virtual void CheckForAbortRender() {}
  virtual int CheckForAbortComposite() { return 0; }
 
 
  vtkSetMacro(UseBackBuffer, int);
  vtkGetMacro(UseBackBuffer, int);
  vtkBooleanMacro(UseBackBuffer, int);
 
 
  vtkSetMacro(SynchronizeTileProperties, int);
  vtkGetMacro(SynchronizeTileProperties, int);
  vtkBooleanMacro(SynchronizeTileProperties, int);
 
 
  virtual void GenericStartRenderCallback();
  virtual void GenericEndRenderCallback();
 
protected:
  vtkParallelRenderManager();
  ~vtkParallelRenderManager() override;
 
 
  void AddRenderWindowEventHandlers();
  void RemoveRenderWindowEventHandlers();
 
  vtkRenderWindow* RenderWindow;
  vtkMultiProcessController* Controller;
  vtkRendererCollection* Renderers;
 
  virtual vtkRendererCollection* GetRenderers();
 
  int ForceRenderWindowSize;
  int ForcedRenderWindowSize[2];
 
  int RootProcessId;
 
  int ObservingRenderWindow;
  int ObservingAbort;
 
  unsigned long StartRenderTag;
  unsigned long EndRenderTag;
  unsigned long ResetCameraTag;
  unsigned long ResetCameraClippingRangeTag;
  unsigned long AbortRenderCheckTag;
 
  double ImageReductionFactor;
  double MaxImageReductionFactor;
  int AutoImageReductionFactor;
 
  int WriteBackImages;
  int MagnifyImages;
  int MagnifyImageMethod;
 
  int UseRGBA;
  int SynchronizeTileProperties;
  int FullImageSize[2];
  int ReducedImageSize[2];
 
  vtkUnsignedCharArray* FullImage;
  vtkUnsignedCharArray* ReducedImage;
 
  int FullImageUpToDate;
  int ReducedImageUpToDate;
  int RenderWindowImageUpToDate;
 
  vtkDoubleArray* Viewports;
 
  int Lock;
  int ParallelRendering;
  int RenderEventPropagation;
  int UseCompositing;
  int SyncRenderWindowRenderers;
 
  vtkTimerLog* Timer;
 
  double RenderTime;
  double ImageProcessingTime;
 
  double AverageTimePerPixel;
 
  virtual void SendWindowInformation() {}
  virtual void ReceiveWindowInformation() {}
  virtual void SendRendererInformation(vtkRenderer*) {}
  virtual void ReceiveRendererInformation(vtkRenderer*) {}
 
  virtual void CollectWindowInformation(vtkMultiProcessStream&) {}
  virtual bool ProcessWindowInformation(vtkMultiProcessStream&) { return true; }
  virtual void CollectRendererInformation(vtkRenderer*, vtkMultiProcessStream&) {}
  virtual bool ProcessRendererInformation(vtkRenderer*, vtkMultiProcessStream&) { return true; }
 
 
  virtual void PreRenderProcessing() = 0;
  virtual void PostRenderProcessing() = 0;
 
  virtual void SetRenderWindowSize();
 
  virtual void LocalComputeVisiblePropBounds(vtkRenderer* ren, double bounds[6]);
 
  virtual void MagnifyReducedImage();
 
  virtual void WriteFullImage();
 
  virtual void ReadReducedImage();
 
  virtual int LastRenderInFrontBuffer();
 
  virtual int ChooseBuffer();
 
  virtual void SetRenderWindowPixelData(vtkUnsignedCharArray* pixels, const int pixelDimensions[2]);
 
  virtual int ImageReduceRenderer(vtkRenderer*) { return 1; }
 
  struct RenderWindowInfo
  {
    int FullSize[2];
    int ReducedSize[2];
    int NumberOfRenderers;
    int UseCompositing;
    int TileScale[2];
    double ImageReductionFactor;
    double DesiredUpdateRate;
    double TileViewport[4];
 
    // Initialize members
    RenderWindowInfo() = default;
 
    // Save/restore the struct to/from a stream.
    void Save(vtkMultiProcessStream& stream);
    bool Restore(vtkMultiProcessStream& stream);
  };
 
  struct RendererInfo
  {
    int Draw = 0;
    int NumberOfLights = 0;
    double Viewport[4] = { 0., 0., 0., 0. };
    double CameraPosition[3] = { 0., 0., 0. };
    double CameraFocalPoint[3] = { 0., 0., 0. };
    double CameraViewUp[3] = { 0., 0., 0. };
    double WindowCenter[2] = { 0., 0. };
    double CameraClippingRange[2] = { 0., 0. };
    double CameraViewAngle = 0.;
    double Background[3] = { 0., 0., 0. };
    double Background2[3] = { 0., 0., 0. };
    bool GradientBackground = false;
 
    double ParallelScale = 0.;
 
    // Initialize members
    RendererInfo() = default;
 
    // Save/restore the struct to/from a stream.
    void Save(vtkMultiProcessStream& stream);
    bool Restore(vtkMultiProcessStream& stream);
  };
 
  struct LightInfo
  {
    double Position[3];
    double FocalPoint[3];
    double Type;
 
    // Initialize members
    LightInfo() = default;
 
    // Save/restore the struct to/from a stream.
    void Save(vtkMultiProcessStream& stream);
    bool Restore(vtkMultiProcessStream& stream);
  };
 
  int AddedRMIs;
  unsigned long RenderRMIId;
  unsigned long BoundsRMIId;
  int UseBackBuffer;
 
  static bool DefaultRenderEventPropagation;
 
private:
  vtkParallelRenderManager(const vtkParallelRenderManager&) = delete;
  void operator=(const vtkParallelRenderManager&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif // vtkParalleRenderManager_h