| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
>> 22 //
>> 23 //
>> 24 // $Id: G4OpenGLWin32Viewer.cc,v 1.14 2004/11/15 12:13:08 gbarrand Exp $
>> 25 // GEANT4 tag $Name: geant4-08-00 $
>> 26 //
25 // 27 //
26 // G4OpenGLWin32Viewer : Class to provide Wind << 28 // G4OpenGLWin32Viewer : Class to provide WindowsNT specific
27 // functionality for Ope << 29 // functionality for OpenGL in GEANT4
28 // 30 //
29 // 27/06/2003 : G.Barrand : implementation (at 31 // 27/06/2003 : G.Barrand : implementation (at last !).
30 32
>> 33 #ifdef G4VIS_BUILD_OPENGLWIN32_DRIVER
>> 34
31 #include "G4OpenGLWin32Viewer.hh" 35 #include "G4OpenGLWin32Viewer.hh"
32 #include "G4VViewer.hh" <<
33 #include "G4VSceneHandler.hh" <<
34 #include "G4OpenGLSceneHandler.hh" <<
35 #include "G4Scene.hh" <<
36 36
37 #include "G4ios.hh" 37 #include "G4ios.hh"
38 #include "G4VisExtent.hh" 38 #include "G4VisExtent.hh"
39 #include "G4LogicalVolume.hh" 39 #include "G4LogicalVolume.hh"
40 #include "G4VSolid.hh" 40 #include "G4VSolid.hh"
41 #include "G4Point3D.hh" 41 #include "G4Point3D.hh"
42 #include "G4Normal3D.hh" 42 #include "G4Normal3D.hh"
43 43
44 #include "G4SystemOfUnits.hh" <<
45 44
46 ////////////////////////////////////////////// 45 //////////////////////////////////////////////////////////////////////////////
47 void G4OpenGLWin32Viewer::SetView ( 46 void G4OpenGLWin32Viewer::SetView (
48 ) 47 )
49 ////////////////////////////////////////////// 48 //////////////////////////////////////////////////////////////////////////////
50 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 49 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
51 { 50 {
52 if(!fHDC) return; 51 if(!fHDC) return;
53 if(!fHGLRC) return; 52 if(!fHGLRC) return;
54 ::wglMakeCurrent(fHDC,fHGLRC); 53 ::wglMakeCurrent(fHDC,fHGLRC);
55 G4OpenGLViewer::SetView (); 54 G4OpenGLViewer::SetView ();
56 } 55 }
57 56
58 ////////////////////////////////////////////// 57 //////////////////////////////////////////////////////////////////////////////
59 void G4OpenGLWin32Viewer::ShowView ( 58 void G4OpenGLWin32Viewer::ShowView (
60 ) 59 )
61 ////////////////////////////////////////////// 60 //////////////////////////////////////////////////////////////////////////////
62 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 61 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
63 { 62 {
>> 63 FinishView();
>> 64 }
>> 65
>> 66 //////////////////////////////////////////////////////////////////////////////
>> 67 void G4OpenGLWin32Viewer::FinishView (
>> 68 )
>> 69 //////////////////////////////////////////////////////////////////////////////
>> 70 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
>> 71 {
64 if(!fHDC) return; 72 if(!fHDC) return;
65 glFlush (); 73 glFlush ();
>> 74 ::SwapBuffers(fHDC);
66 // Empty the Windows message queue : 75 // Empty the Windows message queue :
67 MSG event; 76 MSG event;
68 while ( ::PeekMessage(&event, NULL, 0, 0, PM 77 while ( ::PeekMessage(&event, NULL, 0, 0, PM_REMOVE) ) {
69 ::TranslateMessage(&event); 78 ::TranslateMessage(&event);
70 ::DispatchMessage (&event); 79 ::DispatchMessage (&event);
71 } 80 }
72 } 81 }
73 82
74 ////////////////////////////////////////////// 83 //////////////////////////////////////////////////////////////////////////////
75 void G4OpenGLWin32Viewer::GetWin32Connection ( 84 void G4OpenGLWin32Viewer::GetWin32Connection (
76 ) 85 )
77 ////////////////////////////////////////////// 86 //////////////////////////////////////////////////////////////////////////////
78 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 87 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
79 { 88 {
80 } 89 }
81 90
82 ////////////////////////////////////////////// 91 //////////////////////////////////////////////////////////////////////////////
83 void G4OpenGLWin32Viewer::CreateGLWin32Context 92 void G4OpenGLWin32Viewer::CreateGLWin32Context (
84 ) 93 )
85 ////////////////////////////////////////////// 94 //////////////////////////////////////////////////////////////////////////////
86 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 95 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
87 { 96 {
88 } 97 }
89 98
90 ////////////////////////////////////////////// 99 //////////////////////////////////////////////////////////////////////////////
91 void G4OpenGLWin32Viewer::CreateMainWindow ( 100 void G4OpenGLWin32Viewer::CreateMainWindow (
92 ) 101 )
93 ////////////////////////////////////////////// 102 //////////////////////////////////////////////////////////////////////////////
94 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 103 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
95 { 104 {
96 if(fWindow) return; //Done. 105 if(fWindow) return; //Done.
97 106
98 // Bill Gates stuff... 107 // Bill Gates stuff...
99 static const char className[] = "G4OpenGLWin 108 static const char className[] = "G4OpenGLWin32";
100 static G4bool done = false; << 109 static bool done = false;
101 if(done==false) { 110 if(done==false) {
102 WNDCLASS wc; 111 WNDCLASS wc;
103 wc.style = CS_HREDRAW | CS_VREDRAW; 112 wc.style = CS_HREDRAW | CS_VREDRAW;
104 wc.lpfnWndProc = (WNDPROC)WindowProc; 113 wc.lpfnWndProc = (WNDPROC)WindowProc;
105 wc.cbClsExtra = 0; 114 wc.cbClsExtra = 0;
106 wc.cbWndExtra = 0; 115 wc.cbWndExtra = 0;
107 wc.hInstance = ::GetModuleHandle(NULL); 116 wc.hInstance = ::GetModuleHandle(NULL);
108 wc.hIcon = LoadIcon (NULL, IDI_APPLICATIO 117 wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
109 wc.hCursor = LoadCursor(NULL,IDC_CROSS); 118 wc.hCursor = LoadCursor(NULL,IDC_CROSS);
110 wc.hbrBackground = NULL; 119 wc.hbrBackground = NULL;
111 wc.lpszMenuName = className; 120 wc.lpszMenuName = className;
112 wc.lpszClassName = className; 121 wc.lpszClassName = className;
113 ::RegisterClass(&wc); 122 ::RegisterClass(&wc);
114 done = true; 123 done = true;
115 } 124 }
116 125
117 ResizeWindow(fVP.GetWindowSizeHintX(),fVP.Ge << 126 WinSize_x = 400;
>> 127 WinSize_y = 400;
>> 128 if (WinSize_x < fVP.GetWindowSizeHintX ())
>> 129 WinSize_x = fVP.GetWindowSizeHintX ();
>> 130 if (WinSize_y < fVP.GetWindowSizeHintY ())
>> 131 WinSize_y = fVP.GetWindowSizeHintY ();
118 132
119 G4int x_res=GetSystemMetrics(SM_CXSCREEN); << 133 fWindow = ::CreateWindow(className,fName.c_str(),
120 G4int y_res=GetSystemMetrics(SM_CYSCREEN); <<
121 <<
122 //FIXME : NOT tested ! <<
123 fWindow = ::CreateWindowEx(0, className,fNam <<
124 WS_OVERLAPPEDWINDOW, 134 WS_OVERLAPPEDWINDOW,
125 //WS_CHILD | WS_VISIBLE, 135 //WS_CHILD | WS_VISIBLE,
126 // 0,0, << 136 0,0,
127 fVP.GetWindowAbsolu << 137 WinSize_x,WinSize_y,
128 fVP.GetWindowAbsolu <<
129 getWinWidth(), getWinHeight(), <<
130 NULL, NULL, 138 NULL, NULL,
131 ::GetModuleHandle(NULL), 139 ::GetModuleHandle(NULL),
132 NULL); 140 NULL);
133 if(!fWindow) return; 141 if(!fWindow) return;
134 142
135 ::SetWindowLongPtr(fWindow,GWLP_USERDATA,LON << 143 ::SetWindowLong(fWindow,GWL_USERDATA,LONG(this));
136 144
137 // initialize OpenGL rendering : 145 // initialize OpenGL rendering :
138 fHDC = ::GetDC(fWindow); 146 fHDC = ::GetDC(fWindow);
139 if( fHDC && (SetWindowPixelFormat(fHDC)==TRU 147 if( fHDC && (SetWindowPixelFormat(fHDC)==TRUE) ) {
140 fHGLRC = ::wglCreateContext(fHDC); 148 fHGLRC = ::wglCreateContext(fHDC);
141 } 149 }
142 150
143 if(fHDC && fHGLRC) { 151 if(fHDC && fHGLRC) {
144 ::wglMakeCurrent(fHDC,fHGLRC); 152 ::wglMakeCurrent(fHDC,fHGLRC);
145 } 153 }
146 154
147 //G.Barrand : avoid to indirectly pass in <<
148 // WindowProc/[WM_SIZE,WM_PAINT <<
149 // from this method. Else we have <<
150 fInCreateWindow = true; <<
151 <<
152 ::SetForegroundWindow(fWindow); 155 ::SetForegroundWindow(fWindow);
153 ::ShowWindow(fWindow,SW_SHOWDEFAULT); 156 ::ShowWindow(fWindow,SW_SHOWDEFAULT);
154 ::UpdateWindow(fWindow); 157 ::UpdateWindow(fWindow);
155 ::DrawMenuBar(fWindow); 158 ::DrawMenuBar(fWindow);
156 <<
157 fInCreateWindow = false; <<
158 } 159 }
159 160
160 ////////////////////////////////////////////// 161 //////////////////////////////////////////////////////////////////////////////
161 G4OpenGLWin32Viewer::G4OpenGLWin32Viewer ( 162 G4OpenGLWin32Viewer::G4OpenGLWin32Viewer (
162 G4OpenGLSceneHandler& scene 163 G4OpenGLSceneHandler& scene
163 ) 164 )
164 :G4VViewer (scene, -1) 165 :G4VViewer (scene, -1)
165 ,G4OpenGLViewer (scene) 166 ,G4OpenGLViewer (scene)
166 ,fMouseHovered(false) <<
167 ,fMousePressed(false) <<
168 ,fMousePressedX(0) <<
169 ,fMousePressedY(0) <<
170 ,fHDC(0) <<
171 ,fWindow(0) 167 ,fWindow(0)
>> 168 ,fHDC(0)
172 ,fHGLRC(0) 169 ,fHGLRC(0)
173 ,fInCreateWindow(false) <<
174 ////////////////////////////////////////////// 170 //////////////////////////////////////////////////////////////////////////////
175 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 171 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
176 { 172 {
177 } 173 }
178 174
179 ////////////////////////////////////////////// 175 //////////////////////////////////////////////////////////////////////////////
180 G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer ( 176 G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer (
181 ) 177 )
182 ////////////////////////////////////////////// 178 //////////////////////////////////////////////////////////////////////////////
183 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 179 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
184 { 180 {
185 // This is the end (Jim Morisson). 181 // This is the end (Jim Morisson).
186 if (fViewId >= 0) { 182 if (fViewId >= 0) {
187 if(wglGetCurrentContext()!=NULL) wglMakeCu 183 if(wglGetCurrentContext()!=NULL) wglMakeCurrent(NULL,NULL);
188 if(fHGLRC) { 184 if(fHGLRC) {
189 wglDeleteContext(fHGLRC); 185 wglDeleteContext(fHGLRC);
190 fHGLRC = NULL; 186 fHGLRC = NULL;
191 } 187 }
192 188
193 if(fWindow) { 189 if(fWindow) {
194 ::SetWindowLongPtr(fWindow,GWLP_USERDATA << 190 ::SetWindowLong(fWindow,GWL_USERDATA,LONG(NULL));
195 if(fHDC) ::ReleaseDC(fWindow,fHDC); 191 if(fHDC) ::ReleaseDC(fWindow,fHDC);
196 ::DestroyWindow(fWindow); 192 ::DestroyWindow(fWindow);
197 } 193 }
198 } 194 }
199 } 195 }
200 196
201 ////////////////////////////////////////////// 197 //////////////////////////////////////////////////////////////////////////////
202 LRESULT CALLBACK G4OpenGLWin32Viewer::WindowPr << 198 LRESULT CALLBACK G4OpenGLWin32Viewer::WindowProc (
203 HWND aWindow << 199 HWND aWindow
204 ,UINT aMessage << 200 ,UINT aMessage
205 ,WPARAM aWParam 201 ,WPARAM aWParam
206 ,LPARAM aLParam 202 ,LPARAM aLParam
207 ) 203 )
208 ////////////////////////////////////////////// 204 //////////////////////////////////////////////////////////////////////////////
209 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 205 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
210 { 206 {
211 switch (aMessage) { << 207 /*
212 case WM_SIZE: { << 208 switch (aMessage) {
213 //FIXME : have to handle WM_RESIZE << 209 case WM_PAINT:{
214 // Seems to be done (ovidio.pena AT upm. << 210 printf("debug : PAINT\n");
215 auto* This = (G4OpenGLWin32Viewer*) << 211 HDC hDC;
216 ::GetWindowLongPtr(aWindow, << 212 PAINTSTRUCT ps;
217 if (This) { << 213 hDC = BeginPaint(aWindow,&ps);
218 This->fWinSize_x = (G4int) LOWORD(aLPa << 214 if(This) {
219 This->fWinSize_y = (G4int) HIWORD(aLPa << 215 // FIXME : To have an automatic refresh someone have to redraw here.
220 if (!This->fInCreateWindow) { << 216 }
221 This->SetView(); << 217 EndPaint(aWindow, &ps);
222 glViewport(0, 0, This->fWinSize_x, T << 218
223 This->DrawView(); << 219 //FIXME : have to handle WM_RESIZE
224 } << 220 //pView->WinSize_x = (G4int) width;
225 } << 221 //pView->WinSize_y = (G4int) height;
226 return 0; << 222 G4OpenGLWin32Viewer* This =
227 } << 223 (G4OpenGLWin32Viewer*)::GetWindowLong(aWindow,GWL_USERDATA);
228 << 224 if(This) {
229 case WM_PAINT: { <<
230 PAINTSTRUCT ps; <<
231 BeginPaint(aWindow, &ps); <<
232 auto* This = (G4OpenGLWin32Viewer*) <<
233 ::GetWindowLongPtr(aWindow, <<
234 if (This) { <<
235 //FIXME : To have an automatic refresh <<
236 // Seems to be done (ovidio.pena AT up <<
237 if(!This->fInCreateWindow) { <<
238 This->SetView(); <<
239 This->ClearView(); <<
240 This->DrawView(); <<
241 } <<
242 } <<
243 EndPaint(aWindow, &ps); <<
244 return 0; <<
245 } <<
246 <<
247 case WM_LBUTTONDOWN: { <<
248 auto* This = (G4OpenGLWin32Viewer*) <<
249 ::GetWindowLongPtr(aWindow, <<
250 This->TrackMouse(LOWORD(aLParam), HIWORD <<
251 return 0; <<
252 } <<
253 <<
254 case WM_RBUTTONDOWN: { <<
255 auto* This = (G4OpenGLWin32Viewer*) <<
256 ::GetWindowLongPtr(aWindow, <<
257 This->TrackMouse(LOWORD(aLParam), HIWORD <<
258 return 0; <<
259 } <<
260 <<
261 case WM_LBUTTONUP: { <<
262 auto* This = (G4OpenGLWin32Viewer*) <<
263 ::GetWindowLongPtr(aWindow, <<
264 This->ReleaseMouse(); <<
265 return 0; <<
266 } <<
267 <<
268 case WM_RBUTTONUP: { <<
269 auto* This = (G4OpenGLWin32Viewer*) <<
270 ::GetWindowLongPtr(aWindow, <<
271 This->ReleaseMouse(); <<
272 return 0; <<
273 } <<
274 <<
275 case WM_MOUSEHOVER: { <<
276 auto* This = (G4OpenGLWin32Viewer*) <<
277 ::GetWindowLongPtr(aWindow, <<
278 This->fMouseHovered = true; <<
279 return 0; <<
280 } <<
281 <<
282 case WM_MOUSELEAVE: { <<
283 auto* This = (G4OpenGLWin32Viewer*) <<
284 ::GetWindowLongPtr(aWindow, <<
285 This->fMouseHovered = false; <<
286 return 0; <<
287 } <<
288 <<
289 case WM_MOUSEMOVE: { <<
290 auto* This = (G4OpenGLWin32Viewer*) <<
291 ::GetWindowLongPtr(aWindow, <<
292 <<
293 if (!This->fMouseHovered) { <<
294 // mouse hover/leave tracking <<
295 TRACKMOUSEEVENT tme; <<
296 tme.cbSize = sizeof(tme); <<
297 tme.dwFlags = TME_HOVER | TME_LEAVE; <<
298 tme.hwndTrack = aWindow; <<
299 tme.dwHoverTime = HOVER_DEFAULT; <<
300 ::TrackMouseEvent(&tme); <<
301 This->fMouseHovered = true; <<
302 } <<
303 <<
304 if (This->fMousePressed) { <<
305 G4int x = (G4int) LOWORD(aLParam); <<
306 G4int y = (G4int) HIWORD(aLParam); <<
307 G4int dx = x - This->fMousePressedX; <<
308 G4int dy = y - This->fMousePressedY; <<
309 This->fMousePressedX = x; <<
310 This->fMousePressedY = y; <<
311 <<
312 if (aWParam == MK_LBUTTON) { // Rotat <<
313 This->SetRotation(dx, dy); <<
314 } <<
315 <<
316 if (aWParam == MK_RBUTTON) { // Shift <<
317 This->SetShift(dx, dy); <<
318 } <<
319 <<
320 This->SetView(); <<
321 This->ClearView(); <<
322 This->DrawView(); <<
323 } <<
324 <<
325 return 0; <<
326 } <<
327 <<
328 case WM_MOUSEWHEEL: { <<
329 auto* This = (G4OpenGLWin32Viewer*) <<
330 ::GetWindowLongPtr(aWindow, <<
331 <<
332 G4int delta = (short) HIWORD(aWParam); <<
333 <<
334 This->SetZoom(delta); <<
335 <<
336 This->SetView(); 225 This->SetView();
>> 226 glViewport(0,0,This->WinSize_x,This->WinSize_y);
337 This->ClearView(); 227 This->ClearView();
338 This->DrawView(); 228 This->DrawView();
339 return 0; << 229 // WARNING : the below empty the Windows message queue...
>> 230 This->FinishView();
340 } 231 }
341 << 232 } return 0;
342 default: << 233 default:
343 return DefWindowProc(aWindow, aMessage, << 234 return DefWindowProc(aWindow,aMessage,aWParam,aLParam);
344 } 235 }
345 // return DefWindowProc(aWindow,aMessage,aWPa << 236 */
>> 237 return DefWindowProc(aWindow,aMessage,aWParam,aLParam);
346 } 238 }
347 239
348 ////////////////////////////////////////////// 240 //////////////////////////////////////////////////////////////////////////////
349 G4bool G4OpenGLWin32Viewer::SetWindowPixelForm << 241 bool G4OpenGLWin32Viewer::SetWindowPixelFormat(
350 HDC aHdc 242 HDC aHdc
351 ) 243 )
352 ////////////////////////////////////////////// 244 //////////////////////////////////////////////////////////////////////////////
353 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 245 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
354 { 246 {
355 // The ungessable... 247 // The ungessable...
356 248
357 PIXELFORMATDESCRIPTOR pfd; 249 PIXELFORMATDESCRIPTOR pfd;
358 pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); 250 pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
359 pfd.nVersion = 1; 251 pfd.nVersion = 1;
360 pfd.dwFlags = 252 pfd.dwFlags =
361 PFD_DRAW_TO_WINDOW | 253 PFD_DRAW_TO_WINDOW |
362 PFD_SUPPORT_OPENGL | 254 PFD_SUPPORT_OPENGL |
363 PFD_DOUBLEBUFFER | 255 PFD_DOUBLEBUFFER |
364 PFD_STEREO_DONTCARE; 256 PFD_STEREO_DONTCARE;
365 pfd.iPixelType = PFD_TYPE_RGBA; 257 pfd.iPixelType = PFD_TYPE_RGBA;
366 pfd.cColorBits = 32; 258 pfd.cColorBits = 32;
367 pfd.cRedBits = 8; 259 pfd.cRedBits = 8;
368 pfd.cRedShift = 16; 260 pfd.cRedShift = 16;
369 pfd.cGreenBits = 8; 261 pfd.cGreenBits = 8;
370 pfd.cGreenShift = 8; 262 pfd.cGreenShift = 8;
371 pfd.cBlueBits = 8; 263 pfd.cBlueBits = 8;
372 pfd.cBlueShift = 0; 264 pfd.cBlueShift = 0;
373 pfd.cAlphaBits = 0; 265 pfd.cAlphaBits = 0;
374 pfd.cAlphaShift = 0; 266 pfd.cAlphaShift = 0;
375 pfd.cAccumBits = 64; 267 pfd.cAccumBits = 64;
376 pfd.cAccumRedBits = 16; 268 pfd.cAccumRedBits = 16;
377 pfd.cAccumGreenBits = 16; 269 pfd.cAccumGreenBits = 16;
378 pfd.cAccumBlueBits = 16; 270 pfd.cAccumBlueBits = 16;
379 pfd.cAccumAlphaBits = 0; 271 pfd.cAccumAlphaBits = 0;
380 pfd.cDepthBits = 32; 272 pfd.cDepthBits = 32;
381 pfd.cStencilBits = 8; 273 pfd.cStencilBits = 8;
382 pfd.cAuxBuffers = 0; 274 pfd.cAuxBuffers = 0;
383 pfd.iLayerType = PFD_MAIN_PLANE; 275 pfd.iLayerType = PFD_MAIN_PLANE;
384 pfd.bReserved = 0; 276 pfd.bReserved = 0;
385 pfd.dwLayerMask = 0; 277 pfd.dwLayerMask = 0;
386 pfd.dwVisibleMask = 0; 278 pfd.dwVisibleMask = 0;
387 pfd.dwDamageMask = 0; 279 pfd.dwDamageMask = 0;
388 280
389 G4int pixelIndex = ::ChoosePixelFormat(aHdc, << 281 int pixelIndex = ::ChoosePixelFormat(aHdc,&pfd);
390 if (pixelIndex==0) { 282 if (pixelIndex==0) {
391 pixelIndex = 1; 283 pixelIndex = 1;
392 if (::DescribePixelFormat(aHdc, 284 if (::DescribePixelFormat(aHdc,
393 pixelIndex, 285 pixelIndex,
394 sizeof(PIXELFORMATDESCRIPTOR), 286 sizeof(PIXELFORMATDESCRIPTOR),
395 &pfd)==0) { 287 &pfd)==0) {
396 return false; 288 return false;
397 } 289 }
398 } 290 }
399 if (::SetPixelFormat(aHdc,pixelIndex,&pfd)== 291 if (::SetPixelFormat(aHdc,pixelIndex,&pfd)==FALSE) return false;
400 return true; 292 return true;
401 } 293 }
402 294
403 ////////////////////////////////////////////// <<
404 void G4OpenGLWin32Viewer::TrackMouse( <<
405 G4int x <<
406 ,G4int y <<
407 ) <<
408 ////////////////////////////////////////////// <<
409 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! <<
410 { <<
411 fMousePressed = true; <<
412 fMousePressedX = x; <<
413 fMousePressedY = y; <<
414 } <<
415 <<
416 ////////////////////////////////////////////// <<
417 void G4OpenGLWin32Viewer::ReleaseMouse( <<
418 ) <<
419 ////////////////////////////////////////////// <<
420 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! <<
421 { <<
422 fMousePressed = false; <<
423 fMousePressedX = 0; <<
424 fMousePressedY = 0; <<
425 } <<
426 <<
427 ////////////////////////////////////////////// <<
428 void G4OpenGLWin32Viewer::SetShift( <<
429 G4int dx <<
430 ,G4int dy <<
431 ) <<
432 ////////////////////////////////////////////// <<
433 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! <<
434 { <<
435 const G4double sceneRadius = GetSceneHandler <<
436 ->GetExtent().Get <<
437 const G4double scale = 300; // Roughly pixe <<
438 const G4double dxScene = dx*sceneRadius/scal <<
439 const G4double dyScene = dy*sceneRadius/scal <<
440 fVP.IncrementPan(-dxScene,dyScene); <<
441 } <<
442 <<
443 ////////////////////////////////////////////// <<
444 void G4OpenGLWin32Viewer::SetRotation( <<
445 G4int dx <<
446 ,G4int dy <<
447 ) <<
448 ////////////////////////////////////////////// <<
449 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! <<
450 { <<
451 // Simple ad-hoc algorithms (borrowed from G <<
452 const G4Vector3D& x_prime = fVP.GetViewpoint <<
453 .cross(fVP.GetUp <<
454 const G4Vector3D& y_prime = x_prime.cross(fV <<
455 const G4double scale = 200; // Roughly pixe <<
456 G4Vector3D newViewpointDirection = fVP.GetVi <<
457 newViewpointDirection += dx*x_prime/scale; <<
458 newViewpointDirection += dy*y_prime/scale; <<
459 fVP.SetViewpointDirection(newViewpointDirect <<
460 <<
461 if (fVP.GetRotationStyle() == G4ViewParamete <<
462 G4Vector3D newUpVector = fVP.GetUpVector <<
463 newUpVector += dx*x_prime/scale; <<
464 newUpVector += dy*y_prime/scale; <<
465 fVP.SetUpVector(newUpVector.unit()); <<
466 } <<
467 } <<
468 <<
469 ////////////////////////////////////////////// <<
470 void G4OpenGLWin32Viewer::SetZoom( <<
471 G4int delta <<
472 ) <<
473 ////////////////////////////////////////////// <<
474 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! <<
475 { <<
476 if (fVP.GetFieldHalfAngle() == 0.) { // O <<
477 const G4double scale = 500; // Empiri <<
478 fVP.MultiplyZoomFactor(1. + delta/scal <<
479 } else { // P <<
480 const G4double scale = fVP.GetFieldHal <<
481 fVP.SetDolly(fVP.GetDolly() + delta/sc <<
482 } <<
483 } <<
484 295
>> 296 #endif
485 297