vtkSynchronizedRenderWindows.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkSynchronizedRenderWindows.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkSynchronizedRenderWindows_h
#define vtkSynchronizedRenderWindows_h
 
#include "vtkObject.h"
#include "vtkRenderingParallelModule.h" // For export macro
 
class vtkRenderWindow;
class vtkMultiProcessController;
class vtkCommand;
class vtkMultiProcessStream;
 
class VTKRENDERINGPARALLEL_EXPORT vtkSynchronizedRenderWindows : public vtkObject
{
public:
  static vtkSynchronizedRenderWindows* New();
  vtkTypeMacro(vtkSynchronizedRenderWindows, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  void SetRenderWindow(vtkRenderWindow*);
  vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
 
 
  void SetParallelController(vtkMultiProcessController*);
  vtkGetObjectMacro(ParallelController, vtkMultiProcessController);
 
 
  void SetIdentifier(unsigned int id);
  vtkGetMacro(Identifier, unsigned int);
 
 
  vtkSetMacro(ParallelRendering, bool);
  vtkGetMacro(ParallelRendering, bool);
  vtkBooleanMacro(ParallelRendering, bool);
 
  // Turns on/off render event propagation.  When on (the default) and
  // ParallelRendering is on, process 0 will send an RMI call to all remote
  // processes to perform a synchronized render.  When off, render must be
  // manually called on each process.
  vtkSetMacro(RenderEventPropagation, bool);
  vtkGetMacro(RenderEventPropagation, bool);
  vtkBooleanMacro(RenderEventPropagation, bool);
 
  virtual void AbortRender();
 
 
  vtkSetMacro(RootProcessId, int);
  vtkGetMacro(RootProcessId, int);
 
  enum
  {
    SYNC_RENDER_TAG = 15001,
  };
 
protected:
  vtkSynchronizedRenderWindows();
  ~vtkSynchronizedRenderWindows() override;
 
  struct RenderWindowInfo
  {
    int WindowSize[2];
    int TileScale[2];
    double TileViewport[4];
    double DesiredUpdateRate;
 
    // Save/restore the struct to/from a stream.
    void Save(vtkMultiProcessStream& stream);
    bool Restore(vtkMultiProcessStream& stream);
    void CopyFrom(vtkRenderWindow*);
    void CopyTo(vtkRenderWindow*);
  };
 
  // These methods are called on all processes as a consequence of corresponding
  // events being called on the render window.
  virtual void HandleStartRender();
  virtual void HandleEndRender() {}
  virtual void HandleAbortRender() {}
 
  virtual void MasterStartRender();
  virtual void SlaveStartRender();
 
  unsigned int Identifier;
  bool ParallelRendering;
  bool RenderEventPropagation;
  int RootProcessId;
 
  vtkRenderWindow* RenderWindow;
  vtkMultiProcessController* ParallelController;
 
private:
  vtkSynchronizedRenderWindows(const vtkSynchronizedRenderWindows&) = delete;
  void operator=(const vtkSynchronizedRenderWindows&) = delete;
 
  class vtkObserver;
  vtkObserver* Observer;
  friend class vtkObserver;
};
 
#endif