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 "vtkRenderingParallelModule.h" // For export macro
#include "vtkObject.h"

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);


  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();

  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&) VTK_DELETE_FUNCTION;
  void operator=(const vtkSynchronizedRenderWindows&) VTK_DELETE_FUNCTION;

  class vtkObserver;
  vtkObserver* Observer;
  friend class vtkObserver;

};

#endif