VTK  9.1.0
vtkSynchronizedRenderers.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkSynchronizedRenderers.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================*/
30#ifndef vtkSynchronizedRenderers_h
31#define vtkSynchronizedRenderers_h
32
33#include "vtkObject.h"
34#include "vtkRenderingParallelModule.h" // For export macro
35#include "vtkSmartPointer.h" // needed for vtkSmartPointer.
36#include "vtkUnsignedCharArray.h" // needed for vtkUnsignedCharArray.
37
38class vtkFXAAOptions;
39class vtkRenderer;
44
45class VTKRENDERINGPARALLEL_EXPORT vtkSynchronizedRenderers : public vtkObject
46{
47public:
50 void PrintSelf(ostream& os, vtkIndent indent) override;
51
53
59 virtual void SetRenderer(vtkRenderer*);
62
64
69 vtkGetObjectMacro(ParallelController, vtkMultiProcessController);
71
73
77 vtkSetMacro(ParallelRendering, bool);
78 vtkGetMacro(ParallelRendering, bool);
79 vtkBooleanMacro(ParallelRendering, bool);
81
83
86 vtkSetClampMacro(ImageReductionFactor, int, 1, 50);
87 vtkGetMacro(ImageReductionFactor, int);
89
91
96 vtkSetMacro(WriteBackImages, bool);
97 vtkGetMacro(WriteBackImages, bool);
98 vtkBooleanMacro(WriteBackImages, bool);
100
102
107 vtkSetMacro(RootProcessId, int);
108 vtkGetMacro(RootProcessId, int);
110
119
121
126 vtkGetObjectMacro(CaptureDelegate, vtkSynchronizedRenderers);
128
130
137 vtkSetMacro(AutomaticEventHandling, bool);
138 vtkGetMacro(AutomaticEventHandling, bool);
139 vtkBooleanMacro(AutomaticEventHandling, bool);
141
143
154 vtkSetMacro(FixBackground, bool);
155 vtkGetMacro(FixBackground, bool);
156 vtkBooleanMacro(FixBackground, bool);
158
159 enum
160 {
161 SYNC_RENDERER_TAG = 15101,
162 RESET_CAMERA_TAG = 15102,
163 COMPUTE_BOUNDS_TAG = 15103
164 };
165
168 struct VTKRENDERINGPARALLEL_EXPORT vtkRawImage
169 {
170 public:
172 {
173 this->Valid = false;
174 this->Size[0] = this->Size[1] = 0;
176 }
177
178 void Resize(int dx, int dy, int numcomps)
179 {
180 this->Valid = false;
181 this->Allocate(dx, dy, numcomps);
182 }
183
187 void Initialize(int dx, int dy, vtkUnsignedCharArray* data);
188
189 void MarkValid() { this->Valid = true; }
190 void MarkInValid() { this->Valid = false; }
191
192 bool IsValid() { return this->Valid; }
193 int GetWidth() { return this->Size[0]; }
194 int GetHeight() { return this->Size[1]; }
195 vtkUnsignedCharArray* GetRawPtr() { return this->Data; }
196
204 bool PushToViewport(vtkRenderer* renderer, bool blend = true);
205
213 bool PushToFrameBuffer(vtkRenderer* ren, bool blend = true);
214
215 // Captures the image from the viewport.
216 // This doesn't trigger a render, just captures what's currently there in
217 // the active buffer.
219
220 // Save the image as a png. Useful for debugging.
221 void SaveAsPNG(VTK_FILEPATH const char* filename);
222
223 private:
224 bool Valid;
225 int Size[2];
227
228 void Allocate(int dx, int dy, int numcomps);
229 };
230
231protected:
234
236 {
238 int Draw;
240 double Viewport[4];
241 double CameraPosition[3];
242 double CameraFocalPoint[3];
243 double CameraViewUp[3];
244 double CameraWindowCenter[2];
245 double CameraClippingRange[2];
248 double EyeTransformMatrix[16];
249 double ModelTransformMatrix[16];
250
251 // Save/restore the struct to/from a stream.
254
257 };
258
259 // These methods are called on all processes as a consequence of corresponding
260 // events being called on the renderer.
261 virtual void HandleStartRender();
262 virtual void HandleEndRender();
263 virtual void HandleAbortRender() {}
264
265 virtual void MasterStartRender();
266 virtual void SlaveStartRender();
267
268 virtual void MasterEndRender();
269 virtual void SlaveEndRender();
270
273
280
285 virtual void PushImageToScreen();
286
289
295
296private:
298 void operator=(const vtkSynchronizedRenderers&) = delete;
299
300 class vtkObserver;
301 vtkObserver* Observer;
302 friend class vtkObserver;
303
304 bool UseFXAA;
305 vtkOpenGLFXAAFilter* FXAAFilter;
306
307 double LastViewport[4];
308
309 double LastBackground[3];
310 double LastBackgroundAlpha;
311 bool LastTexturedBackground;
312 bool LastGradientBackground;
313 bool FixBackground;
314};
315
316#endif
Configuration for FXAA implementations.
a simple class to control print indentation
Definition: vtkIndent.h:113
Multiprocessing communication superclass.
stream used to pass data across processes using vtkMultiProcessController.
abstract base class for most VTK objects
Definition: vtkObject.h:82
Perform FXAA antialiasing on the current framebuffer.
OpenGL renderer.
abstract specification for renderers
Definition: vtkRenderer.h:182
Hold a reference to a vtkObjectBase instance.
static vtkSmartPointer< T > New()
Create an instance of a VTK object.
synchronizes renderers across processes.
virtual void SetParallelController(vtkMultiProcessController *)
Set the parallel message communicator.
virtual void SlaveStartRender()
virtual void SetRenderer(vtkRenderer *)
Set the renderer to be synchronized by this instance.
static vtkSynchronizedRenderers * New()
virtual vtkRawImage & CaptureRenderedImage()
Can be used in HandleEndRender(), MasterEndRender() or SlaveEndRender() calls to capture the rendered...
virtual void HandleStartRender()
vtkSynchronizedRenderers * CaptureDelegate
~vtkSynchronizedRenderers() override
virtual void HandleEndRender()
void CollectiveExpandForVisiblePropBounds(double bounds[6])
Computes visible prob bounds.
virtual vtkRenderer * GetRenderer()
Set the renderer to be synchronized by this instance.
vtkMultiProcessController * ParallelController
virtual void SetCaptureDelegate(vtkSynchronizedRenderers *)
When set, this->CaptureRenderedImage() does not capture image from the screen instead passes the call...
virtual void MasterEndRender()
virtual void SlaveEndRender()
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual void MasterStartRender()
virtual void PushImageToScreen()
Can be used in HandleEndRender(), MasterEndRender() or SlaveEndRender() calls to paste back the image...
dynamic, self-adjusting array of unsigned char
bool Restore(vtkMultiProcessStream &stream)
void Save(vtkMultiProcessStream &stream)
vtkRawImage can be used to make it easier to deal with images for compositing/communicating over clie...
void SaveAsPNG(VTK_FILEPATH const char *filename)
void Initialize(int dx, int dy, vtkUnsignedCharArray *data)
Create the buffer from an image data.
bool PushToViewport(vtkRenderer *renderer, bool blend=true)
Pushes the image to the viewport.
void Resize(int dx, int dy, int numcomps)
bool PushToFrameBuffer(vtkRenderer *ren, bool blend=true)
This is a raw version of PushToViewport() that assumes that the glViewport() has already been setup e...
#define VTK_FILEPATH