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; }