1
2 #ifdef __GNUC__
3 #pragma GCC diagnostic push
4 #pragma GCC diagnostic ignored "-Wunused-parameter"
5
6 #pragma GCC diagnostic push
7 #pragma GCC diagnostic ignored "-Wunused-variable"
8 #endif
9
10
11 #ifdef _WIN32
12 /*
13 Copyright (c) 2012 Advanced Micro Devices, Inc.
14
15 This software is provided 'as-is', without any express or implied warranty.
16 In no event will the authors be held liable for any damages arising from the use of this software.
17 Permission is granted to anyone to use this software for any purpose,
18 including commercial applications, and to alter it and redistribute it freely,
19 subject to the following restrictions:
20
21 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
22 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
23 3. This notice may not be removed or altered from any source distribution.
24 */
25 //Originally written by Erwin Coumans
26
27
28 #ifdef _MSC_VER
29 #pragma warning(disable : 4100)
30 #pragma warning(disable : 4101)
31 #pragma warning(disable : 4189)
32 #pragma warning(disable : 4244)
33 #endif
34
35 #include "Win32Window.h"
36
37 #include "OpenGLInclude.h"
38
39 #include <wchar.h>
40 static InternalData2* sData = 0;
41
42 #include "Win32InternalWindowData.h"
43
44
45 enum
46 {
47 INTERNAL_SHIFT_MODIFIER=1,
48 INTERNAL_ALT_MODIFIER=2,
49 INTERNAL_CONTROL_MODIFIER=4,
50 INTERNAL_TAB_MODIFIER=8,
51 };
52
pumpMessage()53 void Win32Window::pumpMessage()
54 {
55 MSG msg;
56 // check for messages
57 //'if' instead of 'while' can make mainloop smoother.
58 //@todo: use separate threads for input and rendering
59 while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
60 {
61
62 // handle or dispatch messages
63 if ( msg.message == WM_QUIT )
64 {
65 m_data->m_quit = TRUE;
66 }
67 else
68 {
69 TranslateMessage( &msg );
70 DispatchMessage( &msg );
71 }
72
73 // gDemoApplication->displayCallback();
74
75
76 };
77 }
78
getSpecialKeyFromVirtualKeycode(int virtualKeyCode)79 int getSpecialKeyFromVirtualKeycode(int virtualKeyCode)
80 {
81 int keycode = -1;
82 if (virtualKeyCode >= 'A' && virtualKeyCode <= 'Z')
83 {
84 return virtualKeyCode+32;//todo: fix the ascii A vs a input
85 }
86
87 switch (virtualKeyCode)
88 {
89 case VK_RETURN: {keycode = B3G_RETURN; break; };
90 case VK_F1: {keycode = B3G_F1; break;}
91 case VK_F2: {keycode = B3G_F2; break;}
92 case VK_F3: {keycode = B3G_F3; break;}
93 case VK_F4: {keycode = B3G_F4; break;}
94 case VK_F5: {keycode = B3G_F5; break;}
95 case VK_F6: {keycode = B3G_F6; break;}
96 case VK_F7: {keycode = B3G_F7; break;}
97 case VK_F8: {keycode = B3G_F8; break;}
98 case VK_F9: {keycode = B3G_F9; break;}
99 case VK_F10: {keycode= B3G_F10; break;}
100
101 //case VK_SPACE: {keycode= ' '; break;}
102
103 case VK_NEXT: {keycode= B3G_PAGE_DOWN; break;}
104 case VK_PRIOR: {keycode= B3G_PAGE_UP; break;}
105
106 case VK_INSERT: {keycode= B3G_INSERT; break;}
107 case VK_BACK: {keycode= B3G_BACKSPACE; break;}
108 case VK_DELETE: {keycode= B3G_DELETE; break;}
109
110 case VK_END:{keycode= B3G_END; break;}
111 case VK_HOME:{keycode= B3G_HOME; break;}
112 case VK_LEFT:{keycode= B3G_LEFT_ARROW; break;}
113 case VK_UP:{keycode= B3G_UP_ARROW; break;}
114 case VK_RIGHT:{keycode= B3G_RIGHT_ARROW; break;}
115 case VK_DOWN:{keycode= B3G_DOWN_ARROW; break;}
116 case VK_SHIFT:{keycode=B3G_SHIFT;break;}
117 case VK_TAB:{keycode=9;break;}
118 case VK_MENU:{keycode=B3G_ALT;break;}
119 case VK_CONTROL:{keycode=B3G_CONTROL;break;}
120 default:
121 {
122 //keycode = MapVirtualKey( virtualKeyCode, MAPVK_VK_TO_CHAR ) & 0x0000FFFF;
123 }
124 };
125
126 return keycode;
127 }
128
129
getAsciiCodeFromVirtualKeycode(int virtualKeyCode)130 int getAsciiCodeFromVirtualKeycode(int virtualKeyCode)
131 {
132 int keycode = 0xffffffff;
133
134 if (virtualKeyCode >= 'a' && virtualKeyCode <= 'z')
135 {
136 return virtualKeyCode;
137 }
138
139 if (virtualKeyCode >= 'A' && virtualKeyCode <= 'Z')
140 {
141 return virtualKeyCode+32;//todo: fix the ascii A vs a input
142 }
143
144 return keycode;
145 }
146
isModifierKeyPressed(int key)147 bool Win32Window::isModifierKeyPressed(int key)
148 {
149 bool isPressed = false;
150
151 switch (key)
152 {
153 case B3G_ALT:
154 {
155 isPressed = ((sData->m_internalKeyModifierFlags&INTERNAL_ALT_MODIFIER)!=0);
156 break;
157 };
158 case B3G_SHIFT:
159 {
160 isPressed = ((sData->m_internalKeyModifierFlags&INTERNAL_SHIFT_MODIFIER)!=0);
161 break;
162 };
163 case B3G_CONTROL:
164 {
165 isPressed = ((sData->m_internalKeyModifierFlags&INTERNAL_CONTROL_MODIFIER)!=0);
166 break;
167 };
168 case 9: // tab
169 {
170 isPressed = ((sData->m_internalKeyModifierFlags&INTERNAL_TAB_MODIFIER)!=0);
171 break;
172 };
173
174 default:
175 {
176 }
177 };
178 return isPressed;//m_internalKeyModifierFlags
179 }
180
181
WndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)182 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
183 {
184 //printf("msg = %d\n", message);
185 switch (message)
186 {
187
188 case WM_PAINT:
189 {
190 PAINTSTRUCT ps;
191 BeginPaint(hWnd, &ps);
192 EndPaint(hWnd, &ps);
193 }
194 return 1;
195
196 case WM_ERASEBKGND:
197 return 1;
198
199 case WM_CLOSE:
200 if (sData)
201 sData->m_quit = true;
202 //PostQuitMessage(0);
203 return 1;
204
205 case WM_DESTROY:
206 if (sData)
207 sData->m_quit = true;
208 //PostQuitMessage(0);
209 return 1;
210
211 case WM_SYSKEYUP:
212 case WM_KEYUP:
213 {
214
215 int keycode = getSpecialKeyFromVirtualKeycode(wParam);
216 switch (keycode)
217 {
218 case B3G_ALT:
219 {
220 sData->m_internalKeyModifierFlags&=~INTERNAL_ALT_MODIFIER;
221 break;
222 };
223 case B3G_SHIFT:
224 {
225 sData->m_internalKeyModifierFlags &= ~INTERNAL_SHIFT_MODIFIER;
226 break;
227 };
228 case B3G_CONTROL:
229 {
230 sData->m_internalKeyModifierFlags &=~INTERNAL_CONTROL_MODIFIER;
231 break;
232 };
233 case 9: // tab
234 {
235 sData->m_internalKeyModifierFlags &=~INTERNAL_TAB_MODIFIER;
236 break;
237 };
238 }
239
240 if (keycode>=0 && sData && sData->m_keyboardCallback )
241 {
242 int state=0;
243 (*sData->m_keyboardCallback)(keycode,state);
244 }
245 return 0;
246 }
247 case WM_CHAR:
248 {
249 //skip 'enter' key, it is processed in WM_KEYUP/WM_KEYDOWN
250 int keycode = getAsciiCodeFromVirtualKeycode(wParam);
251 if (keycode < 0)
252 {
253 if (sData && sData->m_keyboardCallback && ((HIWORD(lParam) & KF_REPEAT) == 0))
254 {
255 int state = 1;
256 (*sData->m_keyboardCallback)(wParam, state);
257 }
258 }
259 return 0;
260 }
261 case WM_SYSKEYDOWN:
262 case WM_KEYDOWN:
263 {
264 int keycode = getSpecialKeyFromVirtualKeycode(wParam);
265 switch (keycode)
266 {
267 case B3G_ALT:
268 {
269 sData->m_internalKeyModifierFlags|=INTERNAL_ALT_MODIFIER;
270 break;
271 };
272 case B3G_SHIFT:
273 {
274 sData->m_internalKeyModifierFlags |= INTERNAL_SHIFT_MODIFIER;
275 break;
276 };
277 case B3G_CONTROL:
278 {
279 sData->m_internalKeyModifierFlags |=INTERNAL_CONTROL_MODIFIER;
280 break;
281 };
282 case 9: // tab
283 {
284 sData->m_internalKeyModifierFlags |=INTERNAL_TAB_MODIFIER;
285 break;
286 };
287 }
288 if (keycode>=0 && sData && sData->m_keyboardCallback)// && ((HIWORD(lParam) & KF_REPEAT) == 0))
289 {
290 int state = 1;
291 (*sData->m_keyboardCallback)(keycode,state);
292 return 1;
293 }
294 return 0;
295 }
296
297 case WM_MBUTTONUP:
298 {
299 int xPos = LOWORD(lParam);
300 int yPos = HIWORD(lParam);
301 if (sData)
302 {
303 sData->m_mouseMButton=0;
304 sData->m_mouseXpos = xPos;
305 sData->m_mouseYpos = yPos;
306 if (sData && sData->m_mouseButtonCallback)
307 (*sData->m_mouseButtonCallback)(1,0,xPos,yPos);
308 }
309 break;
310 }
311 case WM_MBUTTONDOWN:
312 {
313 int xPos = LOWORD(lParam);
314 int yPos = HIWORD(lParam);
315 if (sData)
316 {
317 sData->m_mouseMButton=1;
318 sData->m_mouseXpos = xPos;
319 sData->m_mouseYpos = yPos;
320 if (sData && sData->m_mouseButtonCallback)
321 (*sData->m_mouseButtonCallback)(1,1,xPos,yPos);
322 }
323 break;
324 }
325
326 case WM_LBUTTONUP:
327 {
328 int xPos = LOWORD(lParam);
329 int yPos = HIWORD(lParam);
330 if (sData)
331 {
332 sData->m_mouseLButton=0;
333 sData->m_mouseXpos = xPos;
334 sData->m_mouseYpos = yPos;
335
336 if (sData && sData->m_mouseButtonCallback)
337 (*sData->m_mouseButtonCallback)(0,0,xPos,yPos);
338
339 }
340 // gDemoApplication->mouseFunc(0,1,xPos,yPos);
341 break;
342 }
343 case WM_LBUTTONDOWN:
344 {
345 int xPos = LOWORD(lParam);
346 int yPos = HIWORD(lParam);
347 if (sData)
348 {
349 sData->m_mouseLButton=1;
350 sData->m_mouseXpos = xPos;
351 sData->m_mouseYpos = yPos;
352
353 if (sData && sData->m_mouseButtonCallback)
354 (*sData->m_mouseButtonCallback)(0,1,xPos,yPos);
355 }
356 break;
357 }
358
359 case 0x020e://WM_MOUSEWHEEL_LEFT_RIGHT
360 {
361
362 int zDelta = (short)HIWORD(wParam);
363 int xPos = LOWORD(lParam);
364 int yPos = HIWORD(lParam);
365 //m_cameraDistance -= zDelta*0.01;
366 if (sData && sData->m_wheelCallback)
367 (*sData->m_wheelCallback)(-float(zDelta)*0.05f,0);
368 return 1;
369 break;
370 }
371 case 0x020A://WM_MOUSEWHEEL:
372 {
373
374 int zDelta = (short)HIWORD(wParam);
375 int xPos = LOWORD(lParam);
376 int yPos = HIWORD(lParam);
377 //m_cameraDistance -= zDelta*0.01;
378 if (sData && sData->m_wheelCallback)
379 (*sData->m_wheelCallback)(0,float(zDelta)*0.05f);
380 return 1;
381 break;
382 }
383
384 case WM_MOUSEMOVE:
385 {
386 int xPos = LOWORD(lParam);
387 int yPos = HIWORD(lParam);
388 sData->m_mouseXpos = xPos;
389 sData->m_mouseYpos = yPos;
390
391 if (sData && sData->m_mouseMoveCallback)
392 (*sData->m_mouseMoveCallback)(xPos,yPos);
393
394 break;
395 }
396 case WM_RBUTTONUP:
397 {
398 int xPos = LOWORD(lParam);
399 int yPos = HIWORD(lParam);
400 sData->m_mouseRButton = 1;
401
402 if (sData && sData->m_mouseButtonCallback)
403 (*sData->m_mouseButtonCallback)(2,0,sData->m_mouseXpos,sData->m_mouseYpos);
404
405 //gDemoApplication->mouseFunc(2,1,xPos,yPos);
406 break;
407 }
408 case WM_RBUTTONDOWN:
409 {
410 int xPos = LOWORD(lParam);
411 int yPos = HIWORD(lParam);
412 sData->m_mouseRButton = 0;
413 if (sData && sData->m_mouseButtonCallback)
414 (*sData->m_mouseButtonCallback)(2,1,sData->m_mouseXpos,sData->m_mouseYpos);
415
416 break;
417 }
418 case WM_QUIT:
419 {
420 return 0;
421 break;
422 }
423 case WM_SIZE: // Size Action Has Taken Place
424
425 RECT clientRect;
426 GetClientRect(hWnd,&clientRect);
427
428 switch (wParam) // Evaluate Size Action
429 {
430
431 case SIZE_MINIMIZED: // Was Window Minimized?
432 return 0; // Return
433
434 case SIZE_MAXIMIZED: // Was Window Maximized?
435 case SIZE_RESTORED: // Was Window Restored?
436 RECT wr;
437 GetWindowRect(hWnd,&wr);
438
439 sData->m_fullWindowWidth = wr.right-wr.left;
440 sData->m_fullWindowHeight = wr.bottom-wr.top;//LOWORD (lParam) HIWORD (lParam);
441 sData->m_openglViewportWidth = clientRect.right;
442 sData->m_openglViewportHeight = clientRect.bottom;
443 glViewport(0, 0, sData->m_openglViewportWidth, sData->m_openglViewportHeight);
444
445 if (sData->m_resizeCallback)
446 (*sData->m_resizeCallback)(sData->m_openglViewportWidth,sData->m_openglViewportHeight);
447 //if (sOpenGLInitialized)
448 //{
449 // //gDemoApplication->reshape(sWidth,sHeight);
450 //}
451 return 0; // Return
452 }
453 break;
454
455 default:{
456
457
458 }
459 };
460
461 return DefWindowProc(hWnd, message, wParam, lParam);
462 }
463
464
465
setWindowTitle(const char * titleChar)466 void Win32Window::setWindowTitle(const char* titleChar)
467 {
468
469 wchar_t windowTitle[1024];
470 swprintf(windowTitle, 1024, L"%hs", titleChar);
471
472 DWORD dwResult;
473
474 #ifdef _WIN64
475 SetWindowTextW(m_data->m_hWnd, windowTitle);
476 #else
477 SendMessageTimeoutW(m_data->m_hWnd, WM_SETTEXT, 0,
478 reinterpret_cast<LPARAM>(windowTitle),
479 SMTO_ABORTIFHUNG, 2000, &dwResult);
480 #endif
481 }
482
createWindow(const b3gWindowConstructionInfo & ci)483 void Win32Window::createWindow(const b3gWindowConstructionInfo& ci)
484 {
485 int oglViewportWidth = ci.m_width;
486 int oglViewportHeight = ci.m_height;
487 bool fullscreen = ci.m_fullscreen;
488 int colorBitsPerPixel = ci.m_colorBitsPerPixel;
489 void* windowHandle = ci.m_windowHandle;
490
491 // get handle to exe file
492 HINSTANCE hInstance = GetModuleHandle(0);
493
494
495 // create the window if we need to and we do not use the null device
496 if (!windowHandle)
497 {
498 #ifdef UNICODE
499 const wchar_t * ClassName = L"DeviceWin32";
500 const wchar_t* emptyString= L"";
501 #else
502 const char* ClassName = "DeviceWin32";
503 const char* emptyString = "";
504 #endif
505 // Register Class
506 WNDCLASSEX wcex;
507 wcex.cbSize = sizeof(WNDCLASSEX);
508 wcex.style = CS_HREDRAW | CS_VREDRAW;
509 wcex.lpfnWndProc = WndProc;
510 wcex.cbClsExtra = 0;
511 wcex.cbWndExtra = 0;
512 wcex.hInstance = hInstance;
513 wcex.hIcon = LoadIcon( NULL, IDI_APPLICATION ); //(HICON)LoadImage(hInstance, "bullet_ico.ico", IMAGE_ICON, 0,0, LR_LOADTRANSPARENT);//LR_LOADFROMFILE);
514 wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
515 wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
516 wcex.lpszMenuName = 0;
517 wcex.lpszClassName = ClassName;
518 wcex.hIconSm = 0;
519
520 // if there is an icon, load it
521 // wcex.hIcon = (HICON)LoadImage(hInstance, "bullet.ico", IMAGE_ICON, 0,0, LR_LOADFROMFILE);
522
523 RegisterClassEx(&wcex);
524
525 // calculate client size
526
527 RECT clientSize;
528 clientSize.top = 0;
529 clientSize.left = 0;
530 clientSize.right = oglViewportWidth;
531 clientSize.bottom = oglViewportHeight;
532
533 DWORD style = WS_POPUP;
534
535 if (!fullscreen)
536 style = WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX;
537
538 AdjustWindowRect(&clientSize, style, false);
539
540 m_data->m_fullWindowWidth = clientSize.right - clientSize.left;
541 m_data->m_fullWindowHeight = clientSize.bottom - clientSize.top;
542
543 int windowLeft = (GetSystemMetrics(SM_CXSCREEN) - m_data->m_fullWindowWidth) / 2;
544 int windowTop = (GetSystemMetrics(SM_CYSCREEN) - m_data->m_fullWindowHeight) / 2;
545
546 if (fullscreen)
547 {
548 windowLeft = 0;
549 windowTop = 0;
550 }
551
552 // create window
553
554 m_data->m_hWnd = CreateWindow( ClassName, emptyString, style, windowLeft, windowTop,
555 m_data->m_fullWindowWidth, m_data->m_fullWindowHeight,NULL, NULL, hInstance, NULL);
556
557
558 RECT clientRect;
559 GetClientRect(m_data->m_hWnd,&clientRect);
560
561
562
563 ShowWindow(m_data->m_hWnd, SW_SHOW);
564 UpdateWindow(m_data->m_hWnd);
565
566 MoveWindow(m_data->m_hWnd, windowLeft, windowTop, m_data->m_fullWindowWidth, m_data->m_fullWindowHeight, TRUE);
567
568 GetClientRect(m_data->m_hWnd,&clientRect);
569 int w = clientRect.right-clientRect.left;
570 int h = clientRect.bottom-clientRect.top;
571 // printf("actual client OpenGL viewport width / height = %d, %d\n",w,h);
572 m_data->m_openglViewportHeight = h;
573 m_data->m_openglViewportWidth = w;
574
575 }
576 else if (windowHandle)
577 {
578 // attach external window
579 m_data->m_hWnd = static_cast<HWND>(windowHandle);
580 RECT r;
581 GetWindowRect(m_data->m_hWnd, &r);
582 m_data->m_fullWindowWidth = r.right - r.left;
583 m_data->m_fullWindowHeight= r.bottom - r.top;
584
585
586 //sFullScreen = false;
587 //sExternalWindow = true;
588 }
589
590
591 if (fullscreen)
592 {
593 DEVMODE dm;
594 memset(&dm, 0, sizeof(dm));
595 dm.dmSize = sizeof(dm);
596 // use default values from current setting
597 EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm);
598 m_data->m_oldScreenWidth = dm.dmPelsWidth;
599 m_data->m_oldHeight = dm.dmPelsHeight;
600 m_data->m_oldBitsPerPel = dm.dmBitsPerPel;
601
602 dm.dmPelsWidth = oglViewportWidth;
603 dm.dmPelsHeight = oglViewportHeight;
604 if (colorBitsPerPixel)
605 {
606 dm.dmBitsPerPel = colorBitsPerPixel;
607 }
608 dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
609
610 LONG res = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
611 if (res != DISP_CHANGE_SUCCESSFUL)
612 { // try again without forcing display frequency
613 dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
614 res = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
615 }
616
617 }
618
619
620 }
621
622
switchFullScreen(bool fullscreen,int width,int height,int colorBitsPerPixel)623 void Win32Window::switchFullScreen(bool fullscreen,int width,int height,int colorBitsPerPixel)
624 {
625
626 LONG res;
627 DEVMODE dm;
628 memset(&dm, 0, sizeof(dm));
629 dm.dmSize = sizeof(dm);
630 // use default values from current setting
631 EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm);
632
633 dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
634
635 if (fullscreen && !m_data->m_oldScreenWidth)
636 {
637 m_data->m_oldScreenWidth = dm.dmPelsWidth;
638 m_data->m_oldHeight = dm.dmPelsHeight;
639 m_data->m_oldBitsPerPel = dm.dmBitsPerPel;
640
641 if (width && height)
642 {
643 dm.dmPelsWidth = width;
644 dm.dmPelsHeight = height;
645 } else
646 {
647 dm.dmPelsWidth = m_data->m_fullWindowWidth;
648 dm.dmPelsHeight = m_data->m_fullWindowHeight;
649 }
650 if (colorBitsPerPixel)
651 {
652 dm.dmBitsPerPel = colorBitsPerPixel;
653 }
654 } else
655 {
656 if (m_data->m_oldScreenWidth)
657 {
658 dm.dmPelsWidth = m_data->m_oldScreenWidth;
659 dm.dmPelsHeight= m_data->m_oldHeight;
660 dm.dmBitsPerPel = m_data->m_oldBitsPerPel;
661 }
662 }
663
664 if (fullscreen)
665 {
666
667 res = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
668 if (!res)
669 {
670 dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
671 res = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
672 }
673
674 DWORD style = WS_POPUP;
675 SetWindowLong(m_data->m_hWnd, GWL_STYLE, style);
676
677 MoveWindow(m_data->m_hWnd, 0, 0, m_data->m_fullWindowWidth, m_data->m_fullWindowHeight, TRUE);
678
679 SetWindowPos(m_data->m_hWnd, NULL,0,0, (int)width, (int)height,
680 SWP_FRAMECHANGED |SWP_SHOWWINDOW);//|SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOOWNERZORDER | SWP_NOREPOSITION | SWP_NOZORDER);
681
682
683 } else
684 {
685 res = ChangeDisplaySettings(&dm, 0);
686
687 DWORD style = WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX;
688 SetWindowLong(m_data->m_hWnd, GWL_STYLE, style);
689
690 SetWindowPos(m_data->m_hWnd, NULL,0,0, (int)width, (int)height,
691 SWP_FRAMECHANGED |SWP_SHOWWINDOW);
692 //|SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOOWNERZORDER | SWP_NOREPOSITION | SWP_NOZORDER);
693
694 }
695
696
697 }
698
699
700
Win32Window()701 Win32Window::Win32Window()
702 {
703 m_data = new InternalData2();
704 sData = m_data;
705
706 }
707
~Win32Window()708 Win32Window::~Win32Window()
709 {
710 setKeyboardCallback(0);
711 setMouseMoveCallback(0);
712 setMouseButtonCallback(0);
713 setWheelCallback(0);
714 setResizeCallback(0);
715
716 sData = 0;
717 delete m_data;
718
719 }
720
setRenderCallback(b3RenderCallback renderCallback)721 void Win32Window::setRenderCallback( b3RenderCallback renderCallback)
722 {
723
724 }
725
closeWindow()726 void Win32Window::closeWindow()
727 {
728 setKeyboardCallback(0);
729 setMouseMoveCallback(0);
730 setMouseButtonCallback(0);
731 setWheelCallback(0);
732 setResizeCallback(0);
733 setRenderCallback(0);
734
735
736 DestroyWindow(this->m_data->m_hWnd);
737 }
738
getMouseCoordinates(int & x,int & y)739 void Win32Window::getMouseCoordinates(int& x, int& y)
740 {
741 x = m_data->m_mouseXpos;
742 y = m_data->m_mouseYpos;
743
744 }
745
runMainLoop()746 void Win32Window::runMainLoop()
747 {
748
749 }
750
751
startRendering()752 void Win32Window::startRendering()
753 {
754 pumpMessage();
755
756 // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); //clear buffers
757
758 //glCullFace(GL_BACK);
759 //glFrontFace(GL_CCW);
760 // glEnable(GL_DEPTH_TEST);
761
762
763
764 }
765
766
renderAllObjects()767 void Win32Window::renderAllObjects()
768 {
769 }
770
endRendering()771 void Win32Window::endRendering()
772 {
773 SwapBuffers( m_data->m_hDC );
774 }
775
getTimeInSeconds()776 float Win32Window::getTimeInSeconds()
777 {
778 return 0.f;
779 }
780
setDebugMessage(int x,int y,const char * message)781 void Win32Window::setDebugMessage(int x,int y,const char* message)
782 {
783 }
784
setRequestExit()785 void Win32Window::setRequestExit()
786 {
787 m_data->m_quit = true;
788 }
requestedExit() const789 bool Win32Window::requestedExit() const
790 {
791 return m_data->m_quit;
792 }
793
setWheelCallback(b3WheelCallback wheelCallback)794 void Win32Window::setWheelCallback(b3WheelCallback wheelCallback)
795 {
796 m_data->m_wheelCallback = wheelCallback;
797 }
798
setMouseMoveCallback(b3MouseMoveCallback mouseCallback)799 void Win32Window::setMouseMoveCallback(b3MouseMoveCallback mouseCallback)
800 {
801 m_data->m_mouseMoveCallback = mouseCallback;
802 }
803
setMouseButtonCallback(b3MouseButtonCallback mouseCallback)804 void Win32Window::setMouseButtonCallback(b3MouseButtonCallback mouseCallback)
805 {
806 m_data->m_mouseButtonCallback = mouseCallback;
807 }
808
setResizeCallback(b3ResizeCallback resizeCallback)809 void Win32Window::setResizeCallback(b3ResizeCallback resizeCallback)
810 {
811 m_data->m_resizeCallback = resizeCallback;
812 if (m_data->m_resizeCallback)
813 (*m_data->m_resizeCallback)(m_data->m_openglViewportWidth,m_data->m_openglViewportHeight);
814 }
815
setKeyboardCallback(b3KeyboardCallback keyboardCallback)816 void Win32Window::setKeyboardCallback( b3KeyboardCallback keyboardCallback)
817 {
818 m_data->m_keyboardCallback = keyboardCallback;
819
820 }
821
getKeyboardCallback()822 b3KeyboardCallback Win32Window::getKeyboardCallback()
823 {
824 return m_data->m_keyboardCallback;
825 }
826
getMouseMoveCallback()827 b3MouseMoveCallback Win32Window::getMouseMoveCallback()
828 {
829 return m_data->m_mouseMoveCallback;
830 }
getMouseButtonCallback()831 b3MouseButtonCallback Win32Window::getMouseButtonCallback()
832 {
833 return m_data->m_mouseButtonCallback;
834 }
getResizeCallback()835 b3ResizeCallback Win32Window::getResizeCallback()
836 {
837 return m_data->m_resizeCallback;
838 }
getWheelCallback()839 b3WheelCallback Win32Window::getWheelCallback()
840 {
841 return m_data->m_wheelCallback;
842 }
843 #endif
844
845
846
847 #ifdef __GNUC__
848 #pragma GCC diagnostic pop
849 #pragma GCC diagnostic pop
850 #endif