forked from Kitware/VTK
/
vtkWin32OpenGLRenderWindow.h
332 lines (274 loc) · 8.84 KB
/
vtkWin32OpenGLRenderWindow.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
/*=========================================================================
Program: Visualization Toolkit
Module: vtkWin32OpenGL2RenderWindow.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.
=========================================================================*/
/**
* @class vtkWin32OpenGL2RenderWindow
* @brief OpenGL rendering window
*
* vtkWin32OpenGL2RenderWindow is a concrete implementation of the abstract
* class vtkRenderWindow. vtkWin32OpenGL2Renderer interfaces to the standard
* OpenGL graphics library in the Windows/NT environment..
*/
#ifndef vtkWin32OpenGLRenderWindow_h
#define vtkWin32OpenGLRenderWindow_h
#include "vtkRenderingOpenGL2Module.h" // For export macro
#include <stack> // for ivar
#include "vtkOpenGLRenderWindow.h"
#include "vtkWindows.h" // For windows API
class vtkIdList;
class VTKRENDERINGOPENGL2_EXPORT vtkWin32OpenGLRenderWindow : public vtkOpenGLRenderWindow
{
public:
static vtkWin32OpenGLRenderWindow *New();
vtkTypeMacro(vtkWin32OpenGLRenderWindow,vtkOpenGLRenderWindow);
void PrintSelf(ostream& os, vtkIndent indent) override;
/**
* Begin the rendering process.
*/
void Start(void) override;
/**
* End the rendering process and display the image.
*/
void Frame(void) override;
/**
* Create the window
*/
virtual void WindowInitialize(void);
/**
* Initialize the rendering window. This will setup all system-specific
* resources. This method and Finalize() must be symmetric and it
* should be possible to call them multiple times, even changing WindowId
* in-between. This is what WindowRemap does.
*/
void Initialize(void) override;
/**
* Finalize the rendering window. This will shutdown all system-specific
* resources. After having called this, it should be possible to destroy
* a window that was used for a SetWindowId() call without any ill effects.
*/
void Finalize(void) override;
/**
* Change the window to fill the entire screen.
*/
void SetFullScreen(int) override;
/**
* Remap the window.
*/
void WindowRemap(void) override;
/**
* Set the preferred window size to full screen.
*/
virtual void PrefFullScreen(void);
//@{
/**
* Set the size of the window in pixels.
*/
void SetSize(int,int) override;
void SetSize(int a[2]) override {vtkOpenGLRenderWindow::SetSize(a);}
//@}
/**
* Get the current size of the window in pixels.
*/
int *GetSize() override;
//@{
/**
* Set the position of the window.
*/
void SetPosition(int,int) override;
void SetPosition(int a[2]) override {vtkOpenGLRenderWindow::SetPosition(a);}
//@}
/**
* Get the current size of the screen in pixels.
*/
int *GetScreenSize() override;
/**
* Get the position in screen coordinates of the window.
*/
int *GetPosition() override;
/**
* Set the name of the window. This appears at the top of the window
* normally.
*/
void SetWindowName(const char *) override;
/**
* Set this RenderWindow's window id to a pre-existing window.
*/
void SetWindowInfo(char *) override;
/**
* Sets the WindowInfo that will be used after a WindowRemap.
*/
void SetNextWindowInfo(char *) override;
/**
* Sets the HWND id of the window that WILL BE created.
*/
void SetParentInfo(char *) override;
void *GetGenericDisplayId() override {return (void *)this->ContextId;}
void *GetGenericWindowId() override {return (void *)this->WindowId;}
void *GetGenericParentId() override {return (void *)this->ParentId;}
void *GetGenericContext() override {return (void *)this->DeviceContext;}
void *GetGenericDrawable() override {return (void *)this->WindowId;}
void SetDisplayId(void *) override;
/**
* Get the window id.
*/
HWND GetWindowId();
//@{
/**
* Set the window id to a pre-existing window.
*/
void SetWindowId(HWND);
void SetWindowId(void *foo) override {this->SetWindowId((HWND)foo);}
//@}
/**
* Initialize the render window from the information associated
* with the currently activated OpenGL context.
*/
bool InitializeFromCurrentContext() override;
//@{
/**
* Set the window's parent id to a pre-existing window.
*/
void SetParentId(HWND);
void SetParentId(void *foo) override {this->SetParentId((HWND)foo);}
//@}
void SetContextId(HGLRC); // hsr
void SetDeviceContext(HDC); // hsr
/**
* Set the window id of the new window once a WindowRemap is done.
*/
void SetNextWindowId(HWND);
/**
* Set the window id of the new window once a WindowRemap is done.
* This is the generic prototype as required by the vtkRenderWindow
* parent.
*/
void SetNextWindowId(void *arg) override;
/**
* Prescribe that the window be created in a stereo-capable mode. This
* method must be called before the window is realized. This method
* overrides the superclass method since this class can actually check
* whether the window has been realized yet.
*/
void SetStereoCapableWindow(int capable) override;
/**
* Make this windows OpenGL context the current context.
*/
void MakeCurrent() override;
/**
* Tells if this window is the current OpenGL context for the calling thread.
*/
bool IsCurrent() override;
/**
* Get report of capabilities for the render window
*/
const char *ReportCapabilities() override;
/**
* Is this render window using hardware acceleration? 0-false, 1-true
*/
int IsDirect() override;
/**
* Check to see if a mouse button has been pressed or mouse wheel activated.
* All other events are ignored by this method.
* This is a useful check to abort a long render.
*/
int GetEventPending() override;
//@{
/**
* Initialize OpenGL for this window.
*/
virtual void SetupPalette(HDC hDC);
virtual void SetupPixelFormatPaletteAndContext(
HDC hDC, DWORD dwFlags, int debug,
int bpp=16, int zbpp=16);
//@}
/**
* Clean up device contexts, rendering contexts, etc.
*/
void Clean();
//@{
/**
* Hide or Show the mouse cursor, it is nice to be able to hide the
* default cursor if you want VTK to display a 3D cursor instead.
* Set cursor position in window (note that (0,0) is the lower left
* corner).
*/
void HideCursor() override;
void ShowCursor() override;
void SetCursorPosition(int x, int y) override;
//@}
/**
* Change the shape of the cursor
*/
void SetCurrentCursor(int) override;
bool DetectDPI() override;
/**
* Override the default implementation so that we can actively switch between
* on and off screen rendering.
*/
void SetOffScreenRendering(int offscreen) override;
//@{
/**
* Ability to push and pop this window's context
* as the current context. The idea being to
* if needed make this window's context current
* and when done releasing resources restore
* the prior context
*/
void PushContext() override;
void PopContext() override;
//@}
/**
* Set the number of vertical syncs required between frames.
* A value of 0 means swap buffers as quickly as possible
* regardless of the vertical refresh. A value of 1 means swap
* buffers in sync with the vertical refresh to elimiate tearing.
* A value of -1 means use a value of 1 unless we missed a frame
* in which case swap immediately. Returns true if the call
* succeeded.
*/
bool SetSwapControl(int i) override;
protected:
vtkWin32OpenGLRenderWindow();
~vtkWin32OpenGLRenderWindow();
HINSTANCE ApplicationInstance;
HPALETTE Palette;
HPALETTE OldPalette;
HGLRC ContextId;
HDC DeviceContext;
BOOL MFChandledWindow;
HWND WindowId;
HWND ParentId;
HWND NextWindowId;
int OwnWindow;
int ScreenSize[2];
std::stack<HGLRC> ContextStack;
std::stack<HDC> DCStack;
int CreatingOffScreenWindow; // to avoid recursion (and memory leaks...)
// message handler
virtual LRESULT MessageProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
static LRESULT APIENTRY WndProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
int CursorHidden;
int ForceMakeCurrent;
int WindowIdReferenceCount;
void ResizeWhileOffscreen(int xsize, int ysize);
void CreateAWindow() override;
void DestroyWindow() override;
void InitializeApplication();
void CleanUpOffScreenRendering(void);
void CreateOffScreenWindow(int width,int height);
void CleanUpRenderers();
void VTKRegisterClass();
private:
vtkWin32OpenGLRenderWindow(const vtkWin32OpenGLRenderWindow&) = delete;
void operator=(const vtkWin32OpenGLRenderWindow&) = delete;
};
#endif