extern BOOL MIOGLGraph_NewWin (OOTint width,OOTint height)
{
GLuint PixelFormat; // Holds The Results After Searching For A Match
WNDCLASS wc; // Windows Class Structure
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
static PIXELFORMATDESCRIPTOR pfd = { // pfd Tells Windows How We Want Things To Be
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
24, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
if(!stGLWinOpen){
WindowRect.left=(long)0; // Set Left Value To 0
WindowRect.right=(long)width; // Set Right Value To Requested Width
WindowRect.top=(long)0; // Set Top Value To 0
WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height
hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = hInstance; // Set The Instance
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For GL
wc.lpszMenuName = NULL; // We Don't Want A Menu
wc.lpszClassName = "OpenGL"; // Set The Class Name
if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{
MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
// Create The Window
if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
"OpenGL", // Class Name
"Turing OpenGL Window", // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
NULL, // No Parent Window
NULL, // No Menu
hInstance, // Instance
NULL))) // Dont Pass Anything To WM_CREATE
{
MIOGLGraph_CloseWin(); // Reset The Display
MessageBox(NULL,"OpenGL Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
{
MIOGLGraph_CloseWin(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
{
MIOGLGraph_CloseWin(); // Reset The Display
MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
{
MIOGLGraph_CloseWin(); // Reset The Display
MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
{
MIOGLGraph_CloseWin(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
{
MIOGLGraph_CloseWin(); // Reset The Display
MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
ShowWindow(hWnd,SW_SHOW); // Show The Window
SetForegroundWindow(hWnd); // Slightly Higher Priority
SetFocus(hWnd); // Sets Keyboard Focus To The Window
//ogl stuff
MySetupOpenGL();
stGLWinOpen = TRUE;
return TRUE;
}
return FALSE;
}
void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
_GLFWmonitor* monitor,
int xpos, int ypos,
int width, int height,
int refreshRate)
{
if (window->monitor == monitor)
{
if (monitor)
{
if (monitor->window == window)
acquireMonitor(window);
}
else
{
RECT rect = { xpos, ypos, xpos + width, ypos + height };
AdjustWindowRectEx(&rect, getWindowStyle(window),
FALSE, getWindowExStyle(window));
SetWindowPos(window->win32.handle, HWND_TOP,
rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
SWP_NOCOPYBITS | SWP_NOACTIVATE | SWP_NOZORDER);
}
return;
}
if (window->monitor)
releaseMonitor(window);
_glfwInputWindowMonitorChange(window, monitor);
if (monitor)
{
GLFWvidmode mode;
DWORD style = GetWindowLongW(window->win32.handle, GWL_STYLE);
UINT flags = SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOCOPYBITS;
if (window->decorated)
{
style &= ~WS_OVERLAPPEDWINDOW;
style |= getWindowStyle(window);
SetWindowLongW(window->win32.handle, GWL_STYLE, style);
flags |= SWP_FRAMECHANGED;
}
_glfwPlatformGetVideoMode(monitor, &mode);
_glfwPlatformGetMonitorPos(monitor, &xpos, &ypos);
SetWindowPos(window->win32.handle, HWND_TOPMOST,
xpos, ypos, mode.width, mode.height,
flags);
acquireMonitor(window);
}
else
{
HWND after;
RECT rect = { xpos, ypos, xpos + width, ypos + height };
DWORD style = GetWindowLongW(window->win32.handle, GWL_STYLE);
UINT flags = SWP_NOACTIVATE | SWP_NOCOPYBITS;
if (window->decorated)
{
style &= ~WS_POPUP;
style |= getWindowStyle(window);
SetWindowLongW(window->win32.handle, GWL_STYLE, style);
flags |= SWP_FRAMECHANGED;
}
if (window->floating)
after = HWND_TOPMOST;
else
after = HWND_NOTOPMOST;
AdjustWindowRectEx(&rect, getWindowStyle(window),
FALSE, getWindowExStyle(window));
SetWindowPos(window->win32.handle, after,
rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
flags);
}
}
void InitWindow(HINSTANCE hInstance)
{
// TODO: make it search all available configs and ask what to load from or something
if(!cfg.LoadFromFile("default.cfg")) LogToFile("debug.log", "Failed to load config");
window_rect.left = 0;
window_rect.right = cfg.scr_width;
window_rect.top = 0;
window_rect.bottom = cfg.scr_height;
window_class.hInstance = hInstance;
window_class.style = CS_VREDRAW | CS_HREDRAW | CS_OWNDC;
window_class.lpfnWndProc = WndProc;
window_class.cbClsExtra = 0;
window_class.cbWndExtra = 0;
window_class.hbrBackground = NULL;
window_class.hIcon = LoadIcon(NULL, IDI_WINLOGO);
window_class.hCursor = LoadCursor(NULL, IDC_ARROW);
window_class.lpszMenuName = NULL;
window_class.lpszClassName = "OpenOrionClass";
fullscreenflag = cfg.fullscreen;
if(!RegisterClass(&window_class))
{
MessageBox(NULL, "Failed to register window class", "RegisterClass() Error", MB_OK | MB_ICONEXCLAMATION);
LogToFile("debug.log", "Failed to register window class");
PostQuitMessage(-1);
}
if(cfg.fullscreen)
{
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings)); // Очистка для хранения установок
dmScreenSettings.dmSize = sizeof(dmScreenSettings); // Размер структуры Devmode
dmScreenSettings.dmPelsWidth = cfg.scr_width; // Ширина экрана
dmScreenSettings.dmPelsHeight = cfg.scr_height; // Высота экрана
dmScreenSettings.dmBitsPerPel = cfg.scr_bpp; // Глубина цвета
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; // Режим Пикселя
DWORD disp;
disp = ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
switch(disp)
{
case DISP_CHANGE_SUCCESSFUL:
{
fullscreenflag = true;
ShowCursor(true);
break;
}
case DISP_CHANGE_BADDUALVIEW:
{
fullscreenflag = false;
ShowCursor(true);
LogToFile("Failed to set fullscreen mode: error (DISP_CHANGE_BADDUALVIEW)");
MessageBox(NULL, "Failed to set fullscreen mode", "DISP_CHANGE_BADDUALVIEW", MB_OK | MB_ICONEXCLAMATION);
break;
}
case DISP_CHANGE_BADFLAGS:
{
fullscreenflag = false;
ShowCursor(true);
LogToFile("Failed to set fullscreen mode: error (DISP_CHANGE_BADFLAGS)");
MessageBox(NULL, "Failed to set fullscreen mode", "DISP_CHANGE_BADFLAGS", MB_OK | MB_ICONEXCLAMATION);
break;
}
case DISP_CHANGE_BADMODE:
{
fullscreenflag = false;
ShowCursor(true);
LogToFile("Failed to set fullscreen mode: error (DISP_CHANGE_BADMODE)");
MessageBox(NULL, "Failed to set fullscreen mode", "DISP_CHANGE_BADMODE", MB_OK | MB_ICONEXCLAMATION);
break;
}
case DISP_CHANGE_BADPARAM:
{
fullscreenflag = false;
ShowCursor(true);
LogToFile("Failed to set fullscreen mode: error (DISP_CHANGE_BADPARAM)");
MessageBox(NULL, "Failed to set fullscreen mode", "DISP_CHANGE_BADPARAM", MB_OK | MB_ICONEXCLAMATION);
break;
}
case DISP_CHANGE_FAILED:
{
fullscreenflag = false;
ShowCursor(true);
LogToFile("Failed to set fullscreen mode: error (DISP_CHANGE_FAILED)");
MessageBox(NULL, "Failed to set fullscreen mode", "DISP_CHANGE_FAILED", MB_OK | MB_ICONEXCLAMATION);
break;
}
case DISP_CHANGE_NOTUPDATED:
{
fullscreenflag = false;
ShowCursor(true);
LogToFile("Failed to set fullscreen mode: error (DISP_CHANGE_NOTUPDATED)");
MessageBox(NULL, "Failed to set fullscreen mode", "DISP_CHANGE_NOTUPDATED", MB_OK | MB_ICONEXCLAMATION);
break;
}
case DISP_CHANGE_RESTART:
{
fullscreenflag = false;
ShowCursor(true);
LogToFile("Failed to set fullscreen mode: error (DISP_CHANGE_RESTART)");
MessageBox(NULL, "Failed to set fullscreen mode", "DISP_CHANGE_RESTART", MB_OK | MB_ICONEXCLAMATION);
break;
}
}
}
if(fullscreenflag)
{
dwExStyle = WS_EX_APPWINDOW;
//dwStyle = WS_OVERLAPPED;
dwStyle = WS_POPUP;
}
else
{
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle = WS_OVERLAPPED;
}
AdjustWindowRectEx(&window_rect, dwStyle, false, dwExStyle);
game_window = CreateWindowEx(dwExStyle,
window_class.lpszClassName, GAMENAME,
WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
dwStyle,
GetSystemMetrics(0) - GetSystemMetrics(0)/2 - window_rect.right / 2,
GetSystemMetrics(1) - GetSystemMetrics(1)/2 - window_rect.bottom / 2,
window_rect.right - window_rect.left,
window_rect.bottom - window_rect.top,
NULL, NULL, hInstance, NULL);
if(!game_window)
{
LogToFile("debug.log","Failed to create game window");
MessageBox(NULL, "Failed to create game window", "CreateWindowEx() Error", MB_OK | MB_ICONEXCLAMATION);
PostQuitMessage(-1);
}
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cDepthBits = 24;
pfd.iLayerType = PFD_MAIN_PLANE;
pfd.cColorBits = cfg.scr_bpp;
hDC = GetDC(game_window);
if(!hDC)
{
LogToFile("debug.log","Failed to create device context");
MessageBox(NULL, "Failed to create device context", "GetDC() Error", MB_OK | MB_ICONEXCLAMATION);
PostQuitMessage(-1);
}
pf = ChoosePixelFormat(hDC, &pfd);
if(!pf)
{
LogToFile("debug.log","Failed to choose pixel format");
MessageBox(NULL, "Failed to set pixel format", "ChoosePixelFormat() Error", MB_OK | MB_ICONEXCLAMATION);
PostQuitMessage(-1);
}
if(!SetPixelFormat(hDC, pf, &pfd))
{
LogToFile("debug.log","Failed to set pixel format");
MessageBox(NULL, "Failed to set pixel format", "SetPixelFormat() Error", MB_OK | MB_ICONEXCLAMATION);
PostQuitMessage(-1);
}
hRC = wglCreateContext(hDC);
if(!hRC)
{
LogToFile("debug.log","Failed to create rendering context");
MessageBox(NULL, "Failed to create rendering context", "wglCreateContext() Error", MB_OK | MB_ICONEXCLAMATION);
PostQuitMessage(-1);
}
if(!wglMakeCurrent(hDC, hRC))
{
LogToFile("debug.log","Failed to make current context");
MessageBox(NULL, "Failed to make current context", "wglMakeCurrent() Error", MB_OK | MB_ICONEXCLAMATION);
PostQuitMessage(-1);
}
ShowWindow(game_window, SW_SHOW);
SetForegroundWindow(game_window);
SetFocus(game_window);
}
// Main window program
int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hprev, PSTR cmdline, int ishow)
{
HWND hwnd = NULL;
MSG msg = {0};
WNDCLASSEX wndclassex = {0};
// Init fields we care about
wndclassex.cbSize = sizeof(WNDCLASSEX); // Always set to size of WNDCLASSEX
wndclassex.style = CS_HREDRAW | CS_VREDRAW;
wndclassex.lpfnWndProc = WinProc;
wndclassex.hInstance = hinstance;
wndclassex.lpszClassName = kClassName;
wndclassex.hCursor = (HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(IDC_ARROW),
IMAGE_CURSOR, 0, 0, LR_SHARED);
RegisterClassEx(&wndclassex); // Register the WNDCLASSEX
RECT rect = { 0, 0, kWinWid, kWinHgt }; // Desired window client rect
DWORD winStyleEx = WS_EX_CLIENTEDGE;
DWORD winStyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME |
WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
// Adjust window rect so it gives us our desired client rect when we
// create the window
AdjustWindowRectEx(&rect, winStyle, false, winStyleEx);
// Create the window
hwnd = CreateWindowEx(winStyleEx, // Window extended style
kClassName,
"www.GameTutorials.com -- D3D Fog",
winStyle, // Window style
CW_USEDEFAULT,
CW_USEDEFAULT,
rect.right - rect.left,
rect.bottom - rect.top,
NULL,
NULL,
hinstance,
NULL);
// Init our global 3D object
if(g3D->init(hwnd) == false)
return EXIT_FAILURE; // There's been an error, lets get out of this joint
// Get the client rect and make sure our client is the size we want
GetClientRect(hwnd, &rect);
assert(rect.right == kWinWid && rect.bottom == kWinHgt);
// We set up our projection matrix once because it will never change
g3D->setProjMatrix(DEG2RAD(60), (float)rect.right / (float)rect.bottom, 1.0f, 8192.0f);
// If we can initialize the fog, exit the application
if(!InitFog())
return EXIT_FAILURE;
ShowCursor(FALSE); // Hide cursor
ShowWindow(hwnd, ishow);
UpdateWindow(hwnd);
// Slam the cursor to the middle of the screen
SetCursorPos(GetSystemMetrics(SM_CXSCREEN) >> 1, GetSystemMetrics(SM_CYSCREEN) >> 1);
// While the app is running...
while(1)
{
if(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Handle messages from the OS
{
if(msg.message == WM_QUIT)
break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else if(LockFrameRate()) // Otherwise if it's time to draw
{
static float angle = 0; // Angle of rotation
D3DXMATRIX wMat; // World matrix
CameraMouseInput(); // Move camera via the mouse
// Set the world view to the current camera view
g3D->setViewMatrix(gCamera);
g3D->begin(); // Begin drawing
g3D->clear(kFogColor); // Clear the screen to the fog color
// Rotate around the Y-axis
g3D->setWorldMatrix(D3DXMatrixRotationY(&wMat, DEG2RAD(++angle)));
// Draw 4 cubes
DrawCube(CPos(2,0,0), 0.5f, D3DCOLOR_ARGB(255, 255, 0, 0));
DrawCube(CPos(-2,0,0), 0.5f, D3DCOLOR_ARGB(255, 255, 0, 0));
DrawCube(CPos(0,0,2), 0.5f, D3DCOLOR_ARGB(255, 255, 0, 0));
DrawCube(CPos(0,0,-2), 0.5f, D3DCOLOR_ARGB(255, 255, 0, 0));
// Draw the grid
g3D->setWorldMatrix(D3DXMatrixIdentity(&wMat));
DrawGrid(CPos(0,-2,0), 32, D3DCOLOR_ARGB(255, 0, 200, 0));
g3D->end(); // Finish drawing
}
else
Sleep(1); // Give the OS a tiny bit of time to process other things
} // end of while(1)
ShowCursor(TRUE); // Reshow cursor
g3D->deinit(); // Free up CD3DObj
UnregisterClass(kClassName,hinstance); // Free up WNDCLASSEX
return EXIT_SUCCESS; // Application was a success
}
void ApplicationObject::InitializeWindow(int width, int height, const bool& fullscreen)
{
WNDCLASSEX wc;
DEVMODE dmScreenSettings;
DWORD ExStyle, Style;
RECT WindowSize;
ExStyle = WS_EX_APPWINDOW;
Style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_POPUP;
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = m_instance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hIconSm = wc.hIcon;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = m_name;
wc.cbSize = sizeof(WNDCLASSEX);
RegisterClassEx(&wc);
if(fullscreen)
{
width = GetSystemMetrics(SM_CXSCREEN);
height = GetSystemMetrics(SM_CYSCREEN);
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = (unsigned long)width;
dmScreenSettings.dmPelsHeight = (unsigned long)height;
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
WindowSize.left = 0;
WindowSize.top = 0;
WindowSize.right = GetSystemMetrics(SM_CXSCREEN);
WindowSize.bottom = GetSystemMetrics(SM_CYSCREEN);
}
else
{
width = 1280;
height = 720;
WindowSize.left = (GetSystemMetrics(SM_CXSCREEN) - width) / 2;
WindowSize.top = (GetSystemMetrics(SM_CYSCREEN) - height) / 2;
WindowSize.right = WindowSize.left + width;
WindowSize.bottom = WindowSize.top + height;
}
m_fullscreen = fullscreen;
m_width = width;
m_height = height;
AdjustWindowRectEx(&WindowSize, Style, FALSE, ExStyle);
m_hwnd = CreateWindowEx(ExStyle, m_name, m_name, Style, WindowSize.left, WindowSize.top, WindowSize.right-WindowSize.left, WindowSize.bottom-WindowSize.top, NULL, NULL, m_instance, NULL);
ShowWindow(m_hwnd, SW_SHOW);
SetForegroundWindow(m_hwnd);
SetFocus(m_hwnd);
m_graphics = new GraphicsObject(m_hwnd, m_width, m_height, m_fullscreen);
m_input = new InputObject();
if (!m_input->Initialize(m_instance, m_hwnd, m_width, m_height))
MessageBox(m_hwnd, L"HEY SOMETHING WENT WRONG", L"ERROR OR SOMETHING", 0);
return;
}
/**
* The async window handling thread
*
* @returns VBox status code.
* @param hThreadSelf This thread.
* @param pvUser Request sempahore handle.
*/
DECLCALLBACK(int) vmsvga3dWindowThread(RTTHREAD hThreadSelf, void *pvUser)
{
RT_NOREF(hThreadSelf);
RTSEMEVENT WndRequestSem = (RTSEMEVENT)pvUser;
WNDCLASSEX wc;
/* Register our own window class. */
wc.cbSize = sizeof(wc);
wc.style = CS_OWNDC;
wc.lpfnWndProc = (WNDPROC) vmsvga3dWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = GetModuleHandle("VBoxDD.dll"); /** @todo hardcoded name.. */
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = VMSVGA3D_WNDCLASSNAME;
wc.hIconSm = NULL;
if (!RegisterClassEx(&wc))
{
Log(("RegisterClass failed with %x\n", GetLastError()));
return VERR_INTERNAL_ERROR;
}
LogFlow(("vmsvga3dWindowThread: started loop\n"));
while (true)
{
MSG msg;
if (GetMessage(&msg, 0, 0, 0))
{
if (msg.message == WM_VMSVGA3D_EXIT)
{
/* Signal to the caller that we're done. */
RTSemEventSignal(WndRequestSem);
break;
}
if (msg.message == WM_VMSVGA3D_WAKEUP)
{
continue;
}
if (msg.message == WM_VMSVGA3D_CREATEWINDOW)
{
HWND *pHwnd = (HWND *)msg.wParam;
LPCREATESTRUCT pCS = (LPCREATESTRUCT) msg.lParam;
#ifdef DEBUG_GFX_WINDOW
RECT rectClient;
rectClient.left = 0;
rectClient.top = 0;
rectClient.right = pCS->cx;
rectClient.bottom = pCS->cy;
AdjustWindowRectEx(&rectClient, WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE | WS_CAPTION, FALSE, WS_EX_NOACTIVATE | WS_EX_NOPARENTNOTIFY | WS_EX_TRANSPARENT);
pCS->cx = rectClient.right - rectClient.left;
pCS->cy = rectClient.bottom - rectClient.top;
#endif
*pHwnd = CreateWindowEx(pCS->dwExStyle,
VMSVGA3D_WNDCLASSNAME,
pCS->lpszName,
pCS->style,
#ifdef DEBUG_GFX_WINDOW
0,
0,
#else
pCS->x,
pCS->y,
#endif
pCS->cx,
pCS->cy,
#ifdef DEBUG_GFX_WINDOW
0,
#else
pCS->hwndParent,
#endif
pCS->hMenu,
pCS->hInstance,
NULL);
AssertMsg(*pHwnd, ("CreateWindowEx %x %s %s %x (%d,%d)(%d,%d), %x %x %x error=%x\n", pCS->dwExStyle, pCS->lpszName, VMSVGA3D_WNDCLASSNAME, pCS->style, pCS->x,
pCS->y, pCS->cx, pCS->cy,pCS->hwndParent, pCS->hMenu, pCS->hInstance, GetLastError()));
/* Signal to the caller that we're done. */
RTSemEventSignal(WndRequestSem);
continue;
}
if (msg.message == WM_VMSVGA3D_DESTROYWINDOW)
{
BOOL fRc = DestroyWindow((HWND)msg.wParam);
Assert(fRc); NOREF(fRc);
/* Signal to the caller that we're done. */
RTSemEventSignal(WndRequestSem);
continue;
}
if (msg.message == WM_VMSVGA3D_RESIZEWINDOW)
{
HWND hwnd = (HWND)msg.wParam;
LPCREATESTRUCT pCS = (LPCREATESTRUCT) msg.lParam;
#ifdef DEBUG_GFX_WINDOW
RECT rectClient;
rectClient.left = 0;
rectClient.top = 0;
rectClient.right = pCS->cx;
rectClient.bottom = pCS->cy;
AdjustWindowRectEx(&rectClient, WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE | WS_CAPTION, FALSE, WS_EX_NOACTIVATE | WS_EX_NOPARENTNOTIFY | WS_EX_TRANSPARENT);
pCS->cx = rectClient.right - rectClient.left;
pCS->cy = rectClient.bottom - rectClient.top;
#endif
BOOL fRc = SetWindowPos(hwnd, 0, pCS->x, pCS->y, pCS->cx, pCS->cy, SWP_NOZORDER | SWP_NOMOVE);
Assert(fRc); NOREF(fRc);
/* Signal to the caller that we're done. */
RTSemEventSignal(WndRequestSem);
continue;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
Log(("GetMessage failed with %x\n", GetLastError()));
break;
}
}
Log(("vmsvga3dWindowThread: end loop\n"));
return VINF_SUCCESS;
}
/* returns non zero if ok */
int
mi_create_window(void)
{
RECT rc;
WNDCLASS wc;
TCHAR classname[512];
TCHAR caption[512];
DWORD style;
int x;
int y;
int w;
int h;
if (g_Wnd != 0 || g_Instance != 0)
{
return 0;
}
g_Instance = GetModuleHandle(NULL);
ZeroMemory(&wc, sizeof(wc));
wc.lpfnWndProc = WndProc; /* points to window procedure */
/* name of window class */
str_to_uni(classname, "rdesktop");
wc.lpszClassName = classname;
str_to_uni(caption, "ReactOS Remote Desktop");
wc.hIcon = LoadIcon(g_Instance,
MAKEINTRESOURCE(IDI_MSTSC));
/* Register the window class. */
if (!RegisterClass(&wc))
{
return 0; /* Failed to register window class */
}
rc.left = 0;
rc.right = rc.left + UI_MIN(g_width, g_screen_width);
rc.top = 0;
rc.bottom = rc.top + UI_MIN(g_height, g_screen_height);
if (g_fullscreen)
{
style = WS_POPUP;
}
else
{
style = WS_OVERLAPPED | WS_CAPTION | WS_POPUP | WS_MINIMIZEBOX |
WS_SYSMENU | WS_SIZEBOX | WS_MAXIMIZEBOX;
}
if (g_screen_width < g_width || g_screen_height < g_height)
{
style |= WS_HSCROLL | WS_VSCROLL;
}
AdjustWindowRectEx(&rc, style, 0, 0);
x = CW_USEDEFAULT;
y = CW_USEDEFAULT;
w = rc.right - rc.left;
h = rc.bottom - rc.top;
g_Wnd = CreateWindow(wc.lpszClassName, caption,
style, x, y, w, h,
(HWND) NULL, (HMENU) NULL, g_Instance,
(LPVOID) NULL);
g_clip_left = 0;
g_clip_top = 0;
g_clip_right = g_clip_left + g_width;
g_clip_bottom = g_clip_top + g_height;
if (g_workarea)
{
ShowWindow(g_Wnd, SW_SHOWMAXIMIZED);
}
else
{
ShowWindow(g_Wnd, SW_SHOWNORMAL);
}
UpdateWindow(g_Wnd);
WSAAsyncSelect(g_tcp_sck, g_Wnd, WM_APP + 1, FD_READ);
SetTimer(g_Wnd, 1, 333, 0);
return 1;
}
int WINAPI WinMain( HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{
// this is the winmain function
WNDCLASSEX winclass; // this will hold the class we create
HWND hwnd; // generic window handle
MSG msg; // generic message
HDC hdc; // graphics device context
// first fill in the window class stucture
winclass.cbSize = sizeof(WNDCLASSEX);
winclass.style = CS_DBLCLKS | CS_OWNDC |
CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc = WindowProc;
winclass.cbClsExtra = 0;
winclass.cbWndExtra = 0;
winclass.hInstance = hinstance;
winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName = NULL;
winclass.lpszClassName = WINDOW_CLASS_NAME;
winclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
// register the window class
if (!RegisterClassEx(&winclass))
return(0);
// create the window
if (!(hwnd = CreateWindowEx(NULL, // extended style
WINDOW_CLASS_NAME, // class
WINDOW_TITLE, // title
(WINDOWED_APP ? (WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION) : (WS_POPUP | WS_VISIBLE)),
0,0, // initial x,y
WINDOW_WIDTH,WINDOW_HEIGHT, // initial width, height
NULL, // handle to parent
NULL, // handle to menu
hinstance,// instance of this application
NULL))) // extra creation parms
return(0);
// save the window handle and instance in a global
main_window_handle = hwnd;
main_instance = hinstance;
// resize the window so that client is really width x height
if (WINDOWED_APP)
{
// now resize the window, so the client area is the actual size requested
// since there may be borders and controls if this is going to be a windowed app
// if the app is not windowed then it won't matter
RECT window_rect = {0,0,WINDOW_WIDTH-1,WINDOW_HEIGHT-1};
// make the call to adjust window_rect
AdjustWindowRectEx(&window_rect,
GetWindowStyle(main_window_handle),
GetMenu(main_window_handle) != NULL,
GetWindowExStyle(main_window_handle));
// save the global client offsets, they are needed in DDraw_Flip()
window_client_x0 = -window_rect.left;
window_client_y0 = -window_rect.top;
// now resize the window with a call to MoveWindow()
MoveWindow(main_window_handle,
0, // x position
0, // y position
window_rect.right - window_rect.left, // width
window_rect.bottom - window_rect.top, // height
FALSE);
// show the window, so there's no garbage on first render
ShowWindow(main_window_handle, SW_SHOW);
} // end if windowed
// perform all game console specific initialization
Game_Init();
// enter main event loop
while(1)
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
// test if this is a quit
if (msg.message == WM_QUIT)
break;
// translate any accelerator keys
TranslateMessage(&msg);
// send the message to the window proc
DispatchMessage(&msg);
} // end if
// main game processing goes here
Game_Main();
} // end while
// shutdown game and release all resources
Game_Shutdown();
// return to Windows like this
return(msg.wParam);
} // end WinMain
bool GLWindow::create(int width, int height, int bpp, bool fullscreen)
{
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
m_isFullscreen = fullscreen; //Store the fullscreen flag
m_windowRect.left = (long)0; // Set Left Value To 0
m_windowRect.right = (long)width; // Set Right Value To Requested Width
m_windowRect.top = (long)0; // Set Top Value To 0
m_windowRect.bottom = (long)height; // Set Bottom Value To Requested Height
// fill out the window class structure
m_windowClass.cbSize = sizeof(WNDCLASSEX);
m_windowClass.style = CS_HREDRAW | CS_VREDRAW;
m_windowClass.lpfnWndProc = GLWindow::StaticWndProc; //We set our static method as the event handler
m_windowClass.cbClsExtra = 0;
m_windowClass.cbWndExtra = 0;
m_windowClass.hInstance = m_hinstance;
m_windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION); // default icon
m_windowClass.hCursor = LoadCursor(NULL, IDC_ARROW); // default arrow
m_windowClass.hbrBackground = NULL; // don't need background
m_windowClass.lpszMenuName = NULL; // no menu
m_windowClass.lpszClassName = "GLClass";
m_windowClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO); // windows logo small icon
// register the windows class
if (!RegisterClassEx(&m_windowClass))
{
return false;
}
if (m_isFullscreen) //If we are fullscreen, we need to change the display mode
{
DEVMODE dmScreenSettings; // device mode
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = width; // screen width
dmScreenSettings.dmPelsHeight = height; // screen height
dmScreenSettings.dmBitsPerPel = bpp; // bits per pixel
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{
// setting display mode failed, switch to windowed
MessageBox(NULL, "Display mode failed", NULL, MB_OK);
m_isFullscreen = false;
}
}
if (m_isFullscreen) // Are We Still In Fullscreen Mode?
{
dwExStyle = WS_EX_APPWINDOW; // Window Extended Style
dwStyle = WS_POPUP; // Windows Style
ShowCursor(false); // Hide Mouse Pointer
}
else
{
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle = WS_OVERLAPPEDWINDOW; // Windows Style
}
AdjustWindowRectEx(&m_windowRect, dwStyle, false, dwExStyle); // Adjust Window To True Requested Size
// class registered, so now create our window
m_hwnd = CreateWindowEx(NULL, // extended style
"GLClass", // class name
"BOGLGP - Chapter 3 - Pointy Example", // app name
dwStyle | WS_CLIPCHILDREN |
WS_CLIPSIBLINGS,
0, 0, // x,y coordinate
m_windowRect.right - m_windowRect.left,
m_windowRect.bottom - m_windowRect.top, // width, height
NULL, // handle to parent
NULL, // handle to menu
m_hinstance, // application instance
this); // we pass a pointer to the GLWindow here
// check if window creation failed (hwnd would equal NULL)
if (!m_hwnd)
return 0;
m_hdc = GetDC(m_hwnd);
ShowWindow(m_hwnd, SW_SHOW); // display the window
UpdateWindow(m_hwnd); // update the window
m_lastTime = GetTickCount() / 1000.0f; //Initialize the time
return true;
}
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
GLuint PixelFormat; // Holds The Results After Searching For A Match
WNDCLASS wc; // Windows Class Structure
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
WindowRect.left=(long)0; // Set Left Value To 0
WindowRect.right=(long)width; // Set Right Value To Requested Width
WindowRect.top=(long)0; // Set Top Value To 0
WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height
fullscreen=fullscreenflag; // Set The Global Fullscreen Flag
hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = hInstance; // Set The Instance
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For GL
wc.lpszMenuName = NULL; // We Don't Want A Menu
wc.lpszClassName = "OpenGL"; // Set The Class Name
if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{
MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (fullscreen) // Attempt Fullscreen Mode?
{
DEVMODE dmScreenSettings; // Device Mode
memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared
dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure
dmScreenSettings.dmPelsWidth = width; // Selected Screen Width
dmScreenSettings.dmPelsHeight = height; // Selected Screen Height
dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
// If The Mode Fails, Offer Two Options. Quit Or Use Windowed Mode.
if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
{
fullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE
}
else
{
// Pop Up A Message Box Letting User Know The Program Is Closing.
MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
return FALSE; // Return FALSE
}
}
}
if (fullscreen) // Are We Still In Fullscreen Mode?
{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP; // Windows Style
ShowCursor(FALSE); // Hide Mouse Pointer
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
}
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
// Create The Window
if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
"OpenGL", // Class Name
title, // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
NULL, // No Parent Window
NULL, // No Menu
hInstance, // Instance
NULL))) // Dont Pass Anything To WM_CREATE
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
bits, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
ShowWindow(hWnd,SW_SHOW); // Show The Window
SetForegroundWindow(hWnd); // Slightly Higher Priority
SetFocus(hWnd); // Sets Keyboard Focus To The Window
ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen
if (!InitGL()) // Initialize Our Newly Created GL Window
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
return TRUE; // Success
}
bool GameApplication::InitWindow(int showFlag)
{
const TCHAR *CLASSNAME = TEXT ( "EIAPPCLASS" );
WNDCLASS wc;
ZeroMemory( &wc, sizeof(wc) );
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = GetAppInstance ();
wc.hCursor = LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = GetBackgroundBrush();
wc.lpszClassName = CLASSNAME;
ATOM rc = RegisterClass ( &wc );
assert(rc);
long WinStyle, WinStyleEx;
WinStyleEx = 0;
WinStyle = WS_MINIMIZEBOX | WS_POPUPWINDOW | WS_CAPTION;
RECT rect;
rect.left = rect.top = 0;
long w, h;
GetWindowDims( w, h );
rect.right = w;
rect.bottom = h;
AdjustWindowRectEx ( &rect, WinStyle, false, WinStyleEx );
long width = rect.right - rect.left;
long height = rect.bottom - rect.top;
appWindow = CreateWindowEx (
WinStyleEx,
CLASSNAME,
GetTitle(),
WinStyle,
0,
0,
width,
height,
NULL,
0,
GetAppInstance (),
NULL );
if ( !appWindow )
return false;
long left = ( GetSystemMetrics ( SM_CXSCREEN ) - width ) / 2;
long top = ( GetSystemMetrics ( SM_CYSCREEN ) - height ) / 2;
MoveWindow ( appWindow, left, top, width, height, TRUE );
ShowWindow ( appWindow, showFlag );
UpdateWindow ( appWindow );
return true;
}
LRESULT CView::OnWindowPosChanged(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(uMsg);
UNREFERENCED_PARAMETER(wParam);
UNREFERENCED_PARAMETER(lParam);
if (m_pPicture)
{
CRect rcImage = GetImageRect();
DWORD dwStyle = (DWORD)GetWindowLongPtr(GWL_STYLE);
DWORD dwExStyle = (DWORD)GetWindowLongPtr(GWL_EXSTYLE);
AdjustWindowRectEx(&rcImage, dwStyle, FALSE, dwExStyle);
CRect rcView = GetClientRect();
AdjustWindowRectEx(&rcView, dwStyle, FALSE, dwExStyle);
SCROLLINFO si;
ZeroMemory(&si, sizeof(SCROLLINFO));
si.cbSize = sizeof(si);
si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
si.nMin = 0;
if (rcView.Width() >= rcImage.Width())
{
m_xCurrentScroll = 0;
ShowScrollBar(SB_HORZ, FALSE);
}
else
{
si.nMax = rcImage.Width();
si.nPage = rcView.Width();
si.nPos = m_xCurrentScroll;
SetScrollInfo(SB_HORZ, si, TRUE);
ShowScrollBar(SB_HORZ, TRUE);
}
if (rcView.Height() >= rcImage.Height())
{
m_yCurrentScroll = 0;
ShowScrollBar(SB_VERT, FALSE);
}
else
{
si.nMax = rcImage.Height();
si.nPage = rcView.Height();
si.nPos = m_yCurrentScroll;
SetScrollInfo(SB_VERT, si, TRUE);
ShowScrollBar(SB_VERT, TRUE);
}
int xNewPos = MIN(m_xCurrentScroll, rcImage.Width() - rcView.Width());
m_xCurrentScroll = MAX(xNewPos, 0);
int yNewPos = MIN(m_yCurrentScroll, rcImage.Height() - rcView.Height());
m_yCurrentScroll = MAX(yNewPos, 0);
// Paint the window directly to eliminate flicker
CClientDC dcView(*this);
Paint(dcView);
}
return 0L;
}
BOOL CreateGLWindow(char* title, int width, int height, int bit, bool fullScreenFlag)
{
GLuint PixelFormat;
WNDCLASS wc;
DWORD dwExStyle;
DWORD dwStyle;
RECT WindowRect;
WindowRect.left = 0;
WindowRect.right = width;
WindowRect.top = 0;
WindowRect.bottom = height;
fullscreen = fullScreenFlag;
hInstance = GetModuleHandle(NULL);
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = L"OpenGL";
RegisterClass(&wc);
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle = WS_OVERLAPPEDWINDOW;
AdjustWindowRectEx(&WindowRect, dwStyle, NULL, dwExStyle);
hWnd = CreateWindowEx(dwExStyle, L"OpenGL", (LPCWSTR)title, dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN
, 0, 0, WindowRect.right, WindowRect.bottom, NULL, NULL, hInstance, NULL);
static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW |
PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
24,
0,0,0,0,0,0,
0,
0,
0,
0,
32,
0,
0,
PFD_MAIN_PLANE,
0,
0,0,0
};
hDC = GetDC(hWnd);
PixelFormat = ChoosePixelFormat(hDC, &pfd);
SetPixelFormat(hDC, PixelFormat, &pfd);
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
ShowWindow(hWnd, SW_SHOW);
SetForegroundWindow(hWnd);
SetFocus(hWnd);
//调用opemGL API
Reshape(width, height);
init();
return TRUE;
}
OpenGLWindow::OpenGLWindow(const char* aTitle, int aWidth, int aHeight, bool aIsFullScreen) :
m_WindowHandle(NULL),
m_WindowDeviceContext(NULL),
m_OpenGLContext(NULL),
m_IsFullScreen(aIsFullScreen)
{
//Pass in the window title, and register the window class.
registerWindowClass(aTitle);
//
RECT WindowRect;
WindowRect.top = WindowRect.left = 0;
WindowRect.right = aWidth;
WindowRect.bottom = aHeight;
//Window Extended Style
DWORD extendedWindowStyle = 0;
//Windows Style
DWORD windowStyle = 0;
//Do we hide the cursor?
ShowCursor(WINDOW_SHOW_MOUSE_CURSOR);
if(m_IsFullScreen == true)
{
DEVMODE dmScreenSettings;
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = aWidth;
dmScreenSettings.dmPelsHeight = aHeight;
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
//Change the display settings to fullscreen. On error, throw an exception.
if(ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{
throw Win32Exception("Unable to swith to fullscreen mode");
}
extendedWindowStyle = WS_EX_APPWINDOW;
windowStyle = WS_POPUP;
}
else
{
extendedWindowStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
windowStyle = WS_CAPTION | WS_SYSMENU | WS_VISIBLE | WS_MINIMIZEBOX;
}
//Adjust the window to the true requested size
AdjustWindowRectEx(&WindowRect, windowStyle, false, extendedWindowStyle);
//Now create the OpenGL window
m_WindowHandle = CreateWindowEx(extendedWindowStyle,
aTitle,
aTitle,
WS_CLIPSIBLINGS | WS_CLIPCHILDREN | windowStyle,
WINDOW_DEFAULT_X, WINDOW_DEFAULT_Y,
WindowRect.right - WindowRect.left,
WindowRect.bottom - WindowRect.top,
NULL, NULL,
GetModuleHandle(NULL),
this);
//
if(m_WindowHandle == NULL)
{
throw Win32Exception("Cannot create the main window");
}
//
createOpenGLContext();
//Show the newly created window
ShowWindow(m_WindowHandle, SW_SHOW);
// Call OnSize manually because in fullscreen mode it will be
// called only when the window is created (which is too early
// because OpenGL is not initialized yet).
resize(aWidth, aHeight);
//
m_LastMouseX = -1;
m_LastMouseY = -1;
}
bool createWindow(char* title, int width, int height)
{
WNDCLASS wc;
RECT rect;
rect.left=0;
rect.right=width;
rect.top=0;
rect.bottom=height;
hInstance = GetModuleHandle(NULL);
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC) WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = SAMPLE_NAME;
if(!RegisterClass(&wc)) {
return false;
}
AdjustWindowRectEx(&rect, WS_OVERLAPPEDWINDOW, FALSE, WS_EX_APPWINDOW | WS_EX_WINDOWEDGE);
if(!(hWnd=CreateWindowEx(WS_EX_APPWINDOW|WS_EX_WINDOWEDGE,SAMPLE_NAME,title,
WS_OVERLAPPEDWINDOW|WS_CLIPSIBLINGS|WS_CLIPCHILDREN,
0,0,rect.right-rect.left,rect.bottom-rect.top,
NULL,NULL,hInstance,NULL))) {
releaseWindow();
return false;
}
static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
32,
0, 0,
0, 0,
0, 0,
0, 0,
0,
0, 0, 0, 0,
32,
0,
0,
PFD_MAIN_PLANE,
0,
0, 0, 0
};
if(!(hDC=GetDC(hWnd)))
{
releaseWindow();
OutputDebugString("");
return FALSE;
}
int pixelformat;
if ( (pixelformat = ChoosePixelFormat(hDC, &pfd)) == 0 ){
OutputDebugString("ChoosePixelFormat Failed....");
return FALSE;
}
if (SetPixelFormat(hDC, pixelformat, &pfd) == FALSE){
OutputDebugString("SetPixelFormat Failed....");
return FALSE;
}
if (!(hRC=wglCreateContext(hDC))){
OutputDebugString("Creating HGLRC Failed....");
return FALSE;
}
// Set Vsync
//BOOL (WINAPI *wglSwapIntervalEXT)(int) = NULL;
//if(strstr((char*)glGetString( GL_EXTENSIONS ),"WGL_EXT_swap_control")== 0) {
//}
//else {
//wglSwapIntervalEXT = (BOOL (WINAPI*)(int))wglGetProcAddress("wglSwapIntervalEXT");
//if(wglSwapIntervalEXT) wglSwapIntervalEXT(1);
//}
wglMakeCurrent(hDC,hRC);
ShowWindow(hWnd,SW_SHOW);
SetForegroundWindow(hWnd);
SetFocus(hWnd);
render_resize(width, height);
glClearColor(0.0f,0.0f,0.0f,0.0f);
glClearDepth(1.0f);
return TRUE;
}
