/** TODO: more parameters! */ static int selectPixelFormat(HDC hDC, bool double_buffered) { // Try to select a format that supports multisampling int pixelFormats[32]; BOOL bStatus; UINT numFormats; float fAttributes[] = {0,0}; int iAttributes[] = { WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, WGL_COLOR_BITS_ARB, 24, WGL_ALPHA_BITS_ARB, 8, WGL_DEPTH_BITS_ARB, 24, WGL_STENCIL_BITS_ARB, 0, WGL_DOUBLE_BUFFER_ARB, double_buffered ? GL_TRUE : GL_FALSE, // Multisampling only works when double-buffering is enabled WGL_SAMPLE_BUFFERS_ARB, double_buffered ? GL_TRUE : GL_FALSE, WGL_SAMPLES_ARB, double_buffered ? 4 : 0, 0, 0 }; // Multisampling ? if (iAttributes[17] == GL_TRUE) { // TODO: make sample count configurable for (unsigned samples = 4; samples > 0; samples -= 2) { iAttributes[19] = samples; bStatus = wglChoosePixelFormatARB(hDC, iAttributes, fAttributes,1, pixelFormats, &numFormats); if (bStatus == GL_TRUE && numFormats > 0) { return pixelFormats[0]; } } } else { bStatus = wglChoosePixelFormatARB(hDC, iAttributes, fAttributes,1, pixelFormats, &numFormats); if (bStatus == GL_TRUE && numFormats > 0) return pixelFormats[0]; } // Log a warning here OutputDebugString("selectPixelFormat(): wglChoosePixelFormatARB() failed, falling back to ChoosePixelFormat\n"); // Fall back to standard method PIXELFORMATDESCRIPTOR pfd; pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); pfd.nVersion = 1; pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_GENERIC_ACCELERATED | (double_buffered ? PFD_DOUBLEBUFFER : 0); pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = 32; pfd.cDepthBits = 32; pfd.iLayerType = PFD_MAIN_PLANE; return ChoosePixelFormat(hDC, &pfd); }
/* ==================== GLW_ChoosePixelFormat Returns -1 on failure, or a pixel format ==================== */ static int GLW_ChoosePixelFormat( const HDC hdc, const int multisamples, const bool stereo3D ) { #if !NGD_USE_OPENGL_ES_2_0 FLOAT fAttributes[] = { 0, 0 }; int iAttributes[] = { WGL_SAMPLE_BUFFERS_ARB, ( ( multisamples > 1 ) ? 1 : 0 ), WGL_SAMPLES_ARB, multisamples, WGL_DOUBLE_BUFFER_ARB, TRUE, WGL_STENCIL_BITS_ARB, 8, WGL_DEPTH_BITS_ARB, 24, WGL_RED_BITS_ARB, 8, WGL_BLUE_BITS_ARB, 8, WGL_GREEN_BITS_ARB, 8, WGL_ALPHA_BITS_ARB, 8, WGL_STEREO_ARB, ( stereo3D ? TRUE : FALSE ), 0, 0 }; #endif int pixelFormat = -1; #if !NGD_USE_OPENGL_ES_2_0 UINT numFormats = -1; if ( !wglChoosePixelFormatARB( hdc, iAttributes, fAttributes, 1, &pixelFormat, &numFormats ) ) { return -1; } #else NGD_MISSING_FUNCTIONALITY; #endif // !NGD_USE_OPENGL_ES_2_0 return pixelFormat; }
//----------------------------------------------------------------------------// OpenGLWGLPBTextureTarget::OpenGLWGLPBTextureTarget(OpenGLRendererBase& owner) : OpenGLTextureTarget(owner), d_pixfmt(0), d_pbuffer(0), d_context(0), d_hdc(0), d_prevContext(0), d_prevDC(0) { if (!WGLEW_ARB_pbuffer) CEGUI_THROW(RendererException("WGL_ARB_pbuffer extension is needed to " "use OpenGLWGLPBTextureTarget!")); HDC hdc = wglGetCurrentDC(); uint fmtcnt; wglChoosePixelFormatARB(hdc, pbAttrs, 0, 1, &d_pixfmt, &fmtcnt); if (!fmtcnt) CEGUI_THROW(RendererException( "pbuff creation failure, no suitable pixel formats.")); initialiseTexture(); // set default size (and cause initialisation of the pbuffer) declareRenderSize(Sizef(DEFAULT_SIZE, DEFAULT_SIZE)); }
bool OglContext::createPBuffer(ms_uint32 width, ms_uint32 height) { HPBUFFERARB hPBuffer = NULL; hPBufferDC = NULL; hPBufferRC = NULL; int pixelFormat; int valid = false; UINT numFormats = 0; float fAttributes[] = {0,0}; int samples = MAX_MULTISAMPLE_SAMPLES; while ((!valid || numFormats == 0) && samples >= 0) { int iAttributes[] = { WGL_SAMPLES_ARB,samples, WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE, WGL_SUPPORT_OPENGL_ARB,GL_TRUE, WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB, WGL_COLOR_BITS_ARB,24, WGL_ALPHA_BITS_ARB,8, WGL_DEPTH_BITS_ARB,16, WGL_STENCIL_BITS_ARB,0, WGL_SAMPLE_BUFFERS_ARB,GL_TRUE, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, 0,0 }; valid = wglChoosePixelFormatARB(window,iAttributes,fAttributes,1,&pixelFormat,&numFormats); if (!valid || numFormats == 0) samples -= 2; } if(numFormats == 0) { msSetError(MS_OGLERR, "P-buffer Error: Unable to find an acceptable pixel format.", "OglContext::createPBuffer()"); return FALSE; } if (!(hPBuffer = wglCreatePbufferARB(window, pixelFormat, width, height, 0))) { msSetError(MS_OGLERR, "P-buffer Error: Unable to create P-buffer. glError: %d", "OglContext::createPBuffer()", glGetError()); return FALSE; } if (!(hPBufferDC = wglGetPbufferDCARB(hPBuffer))) { msSetError(MS_OGLERR, "P-buffer Error: Unable to get P-buffer DC. glError: %d", "OglContext::createPBuffer()", glGetError()); return FALSE; } if (!(hPBufferRC = wglCreateContext(hPBufferDC))) { msSetError(MS_OGLERR, "P-buffer Error: Unable to get P-buffer DC. glError: %d", "OglContext::createPBuffer()", glGetError()); return FALSE; } if (wglShareLists(sharingContext,hPBufferRC) == FALSE) { msSetError(MS_OGLERR, "P-buffer Error: Unable to share display lists. glError: %d", "OglContext::createPBuffer()", glGetError()); return FALSE; } return TRUE; }
HRESULT InitContext() { int iMajorVersion=3; int iMinorVersion=0; HDC hDC = GetDC(g_hWnd); PIXELFORMATDESCRIPTOR pfd; ZeroMemory(&pfd,sizeof(pfd)); bool bError=false; if(WGLEW_ARB_create_context && WGLEW_ARB_pixel_format) { const int iPixelFormatAttribList[] = { WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, WGL_DOUBLE_BUFFER_ARB, GL_TRUE, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, WGL_COLOR_BITS_ARB, 32, WGL_DEPTH_BITS_ARB, 24, WGL_STENCIL_BITS_ARB, 8, 0 // End of attributes list }; int iContextAttribs[] = { WGL_CONTEXT_MAJOR_VERSION_ARB, iMajorVersion, WGL_CONTEXT_MINOR_VERSION_ARB, iMinorVersion, WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, 0 // End of attributes list }; int iPixelFormat, iNumFormats; wglChoosePixelFormatARB(hDC, iPixelFormatAttribList, NULL, 1, &iPixelFormat, (UINT*)&iNumFormats); if(!SetPixelFormat(hDC, iPixelFormat, &pfd))return false; hRC = wglCreateContextAttribsARB(hDC, 0, iContextAttribs); // If everything went OK if(hRC) wglMakeCurrent(hDC, hRC); else bError = true; } else bError = true; if(bError) { // Generate error messages char sErrorMessage[255], sErrorTitle[255]; sprintf(sErrorMessage, "OpenGL %d.%d is not supported! Please download latest GPU drivers!", iMajorVersion, iMinorVersion); sprintf(sErrorTitle, "OpenGL %d.%d Not Supported", iMajorVersion, iMinorVersion); MessageBoxA(g_hWnd, sErrorMessage, sErrorTitle, MB_ICONINFORMATION); return false; } return S_OK; }
bool P3DGLMemoryContextPBuffer::Create (unsigned int Width, unsigned int Height, bool NeedAlpha) { int PixelFormat; UINT FormatCount; HDC CurrDeviceContext; CurrDeviceContext = wglGetCurrentDC(); if (wglChoosePixelFormatARB( CurrDeviceContext, NeedAlpha ? PBufferPixelFormatIntAttrsAlpha : PBufferPixelFormatIntAttrsNoAlpha, NULL, 1, &PixelFormat, &FormatCount)) { if (FormatCount == 0) { return(false); } } else { return(false); } PBufferHandle = wglCreatePbufferARB (CurrDeviceContext, PixelFormat, Width, Height, PBufferAttrs); if (PBufferHandle == NULL) { return(false); } PBufferDC = wglGetPbufferDCARB(PBufferHandle); GLContext = wglCreateContext(PBufferDC); if (MakeCurrent()) { return(P3DGLExtInit()); } else { return(false); } return(true); }
static int ChoosePixelFormatARB(_THIS, const int *iAttribs, const FLOAT *fAttribs) { HWND hwnd; HDC hdc; HGLRC hglrc; const char * (WINAPI *wglGetExtensionsStringARB)(HDC) = 0; const char *extensions; int pformat = 0; UINT matches = 0; hwnd = CreateWindow(SDL_Appname, SDL_Appname, WS_POPUP | WS_DISABLED, 0, 0, 10, 10, NULL, NULL, SDL_Instance, NULL); WIN_FlushMessageQueue(); hdc = GetDC(hwnd); SetPixelFormat(hdc, ChoosePixelFormat(hdc, &GL_pfd), &GL_pfd); hglrc = this->gl_data->wglCreateContext(hdc); if ( hglrc ) { this->gl_data->wglMakeCurrent(hdc, hglrc); } wglGetExtensionsStringARB = (const char * (WINAPI *)(HDC)) this->gl_data->wglGetProcAddress("wglGetExtensionsStringARB"); if( wglGetExtensionsStringARB ) { extensions = wglGetExtensionsStringARB(hdc); } else { extensions = NULL; } this->gl_data->WGL_ARB_pixel_format = 0; if( ExtensionSupported("WGL_ARB_pixel_format", extensions) ) { BOOL (WINAPI *wglChoosePixelFormatARB)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); wglChoosePixelFormatARB = (BOOL (WINAPI *)(HDC, const int *, const FLOAT *, UINT, int *, UINT *)) this->gl_data->wglGetProcAddress("wglChoosePixelFormatARB"); if( wglChoosePixelFormatARB && wglChoosePixelFormatARB(hdc, iAttribs, fAttribs, 1, &pformat, &matches) && pformat ) { this->gl_data->WGL_ARB_pixel_format = 1; } } if ( hglrc ) { this->gl_data->wglMakeCurrent(NULL, NULL); this->gl_data->wglDeleteContext(hglrc); } ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); WIN_FlushMessageQueue(); return pformat; }
void WindowRendererSupportGLWin32::setPixelFormat(const DeviceContext* deviceContext, const PixelFormat& pixelFormat) const { HDC hdc = static_cast<const DeviceContextWin32*>(deviceContext)->getHDC(); ushort colourBits = pixelFormat.getRedBits() + pixelFormat.getGreenBits() + pixelFormat.getBlueBits(); ushort alphaBits = pixelFormat.getAlphaBits(); ushort depthBits = 24; ushort stencilBits = 8; ushort samples = 4; PIXELFORMATDESCRIPTOR pfd; memset(&pfd, 0, sizeof(pfd)); pfd.nSize = sizeof(pfd); pfd.nVersion = 1; pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = (BYTE)colourBits; pfd.cAlphaBits = (BYTE)alphaBits; pfd.cDepthBits = (BYTE)depthBits; pfd.cStencilBits = (BYTE)stencilBits; int format = 0; if(mHasMultisample) { vector<int> attribList; attribList.push_back(WGL_DRAW_TO_WINDOW_ARB); attribList.push_back(GL_TRUE); attribList.push_back(WGL_SUPPORT_OPENGL_ARB); attribList.push_back(GL_TRUE); attribList.push_back(WGL_DOUBLE_BUFFER_ARB); attribList.push_back(GL_TRUE); attribList.push_back(WGL_SAMPLE_BUFFERS_ARB); attribList.push_back(GL_TRUE); attribList.push_back(WGL_ACCELERATION_ARB); attribList.push_back(WGL_FULL_ACCELERATION_ARB); attribList.push_back(WGL_COLOR_BITS_ARB); attribList.push_back(colourBits); attribList.push_back(WGL_ALPHA_BITS_ARB); attribList.push_back(alphaBits); attribList.push_back(WGL_DEPTH_BITS_ARB); attribList.push_back(depthBits); attribList.push_back(WGL_STENCIL_BITS_ARB); attribList.push_back(stencilBits); attribList.push_back(WGL_SAMPLES_ARB); attribList.push_back(samples); if(mHasHardwareGamma) { attribList.push_back(WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT); attribList.push_back(GL_TRUE); } attribList.push_back(0); UINT nformats; wglChoosePixelFormatARB(hdc, &(attribList[0]), nullptr, 1, &format, &nformats); } else { format = ChoosePixelFormat(hdc, &pfd); } SetPixelFormat(hdc, format, &pfd); }
void WindowGL3::setupDC() { if (!wglChoosePixelFormatARB || !wglCreateContextAttribsARB) { Window::setupDC(); return; } int nPixCount = 0; int nPixelFormat = -1; int pixAttribs[] = { WGL_SUPPORT_OPENGL_ARB, 1, WGL_DRAW_TO_WINDOW_ARB, 1, WGL_ACCELERATION_ARB, 1, WGL_RED_BITS_ARB, 8, WGL_GREEN_BITS_ARB, 8, WGL_BLUE_BITS_ARB, 8, WGL_DEPTH_BITS_ARB, 16, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, 0 }; wglChoosePixelFormatARB(mHDC, pixAttribs, NULL, 1, &nPixelFormat, (UINT*)&nPixCount); if (nPixelFormat == -1) { std::cerr << "wglChoosePixelFormatARB failed\n"; mHDC = 0; return; } if (mSettings.profile == Context::GL32) { mSettings.context.vMajor = 3; mSettings.context.vMinor = 2; } GLint attribs[] = { WGL_CONTEXT_MAJOR_VERSION_ARB, mSettings.context.vMajor, WGL_CONTEXT_MINOR_VERSION_ARB, mSettings.context.vMinor, 0 }; mHGLRC = wglCreateContextAttribsARB(mHDC, 0, attribs); if (!mHGLRC) { std::cerr << "wglCreateContextAttribsARB failed\n"; return; } }
internal void Win32SetPixelFormat(HDC WindowDC) { int SuggestedPixelFormatIndex = 0; GLuint ExtendedPick = 0; if(wglChoosePixelFormatARB) { int AttribList[] = { WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, WGL_DOUBLE_BUFFER_ARB, GL_TRUE, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, WGL_SAMPLE_BUFFERS_ARB, GL_TRUE, WGL_SAMPLES_ARB, 4, 0, }; wglChoosePixelFormatARB(WindowDC, AttribList, 0, 1, &SuggestedPixelFormatIndex, &ExtendedPick); } if(!ExtendedPick) { PIXELFORMATDESCRIPTOR DesiredPixelFormat = {0}; DesiredPixelFormat.nSize = sizeof(PIXELFORMATDESCRIPTOR); DesiredPixelFormat.nVersion = 1; DesiredPixelFormat.iPixelType = PFD_TYPE_RGBA; DesiredPixelFormat.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER; DesiredPixelFormat.cColorBits = 32; DesiredPixelFormat.cAlphaBits = 8; DesiredPixelFormat.iLayerType = PFD_MAIN_PLANE; SuggestedPixelFormatIndex = ChoosePixelFormat(WindowDC, &DesiredPixelFormat); } PIXELFORMATDESCRIPTOR SuggestedPixelFormat; DescribePixelFormat(WindowDC, SuggestedPixelFormatIndex, sizeof(SuggestedPixelFormat), &SuggestedPixelFormat); SetPixelFormat(WindowDC, SuggestedPixelFormatIndex, &SuggestedPixelFormat); }
//рекурсивная функция, которая выбирает близайший возможный уровень мультисемплинга int selectMaxMultisampleLevel(HDC hDC,GLint *iAttributes,int *multi_level) { iAttributes[19] = *multi_level; float fAttributes[] = {0,0}; int pixelFormat_; UINT numFormats; bool valid=wglChoosePixelFormatARB(hDC,iAttributes,fAttributes,1,&pixelFormat_,&numFormats); if (valid && numFormats>=1) return pixelFormat_; if (*multi_level==1) return -1; else { (*multi_level)/=2; return selectMaxMultisampleLevel(hDC,iAttributes,multi_level); } }
void WGL_SetPixelFormat(HDC hDC, const RenderSystem::Config & config) { PIXELFORMATDESCRIPTOR pfd; memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR)); pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); pfd.nVersion = 1; pfd.dwFlags = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = config.colorBits; pfd.cAlphaBits = config.alphaBits; pfd.cDepthBits = config.depthBits; pfd.cStencilBits = config.stencilBits; int PixelFormat = 0; { int iAttributes[] = { WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, WGL_COLOR_BITS_ARB, config.colorBits, WGL_ALPHA_BITS_ARB, config.alphaBits, WGL_DEPTH_BITS_ARB, config.depthBits, WGL_STENCIL_BITS_ARB, config.stencilBits, WGL_DOUBLE_BUFFER_ARB, GL_TRUE, WGL_SAMPLE_BUFFERS_ARB, config.msaa ? GL_TRUE : GL_FALSE, WGL_SAMPLES_ARB, 4, 0, 0 }; float fAttributes[] = { 0, 0 }; UINT numFormats = 0; if (WGLEW_GET_FUN(__wglewChoosePixelFormatARB) != NULL) wglChoosePixelFormatARB(hDC, iAttributes, fAttributes, 1, &PixelFormat, &numFormats); if (numFormats == 0) PixelFormat = ChoosePixelFormat(hDC, &pfd); } SetPixelFormat(hDC, PixelFormat, &pfd); }
/* Creates the real pixel format for the target window */ static int gl_choose_pixel_format(HDC hdc, struct gs_init_data *info) { struct darray attribs; int color_bits = get_color_format_bits(info->format); int depth_bits = get_depth_format_bits(info->zsformat); int stencil_bits = get_stencil_format_bits(info->zsformat); UINT num_formats; BOOL success; int format; if (!color_bits) { blog(LOG_ERROR, "gl_init_pixel_format: color format not " "supported"); return false; } darray_init(&attribs); add_attrib(&attribs, WGL_DRAW_TO_WINDOW_ARB, GL_TRUE); add_attrib(&attribs, WGL_SUPPORT_OPENGL_ARB, GL_TRUE); add_attrib(&attribs, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB); add_attrib(&attribs, WGL_DOUBLE_BUFFER_ARB, GL_TRUE); add_attrib(&attribs, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB); add_attrib(&attribs, WGL_COLOR_BITS_ARB, color_bits); add_attrib(&attribs, WGL_DEPTH_BITS_ARB, depth_bits); add_attrib(&attribs, WGL_STENCIL_BITS_ARB, stencil_bits); add_attrib(&attribs, 0, 0); success = wglChoosePixelFormatARB(hdc, attribs.array, NULL, 1, &format, &num_formats); if (!success || !num_formats) { blog(LOG_ERROR, "wglChoosePixelFormatARB failed, %u", GetLastError()); format = 0; } darray_free(&attribs); return format; }
/////////////////////////////////////////////////////////////////////////////// // Setup the actual window and related state. // Create the window, find a pixel format, create the OpenGL context bool SetupWindow(int nWidth, int nHeight) { bool bRetVal = true; int nWindowX = 0; int nWindowY = 0; int nPixelFormat = -1; PIXELFORMATDESCRIPTOR pfd; DWORD dwExtStyle; DWORD dwWindStyle; HINSTANCE g_hInstance = GetModuleHandle(NULL); TCHAR szWindowName[50] = TEXT("Block Redux"); TCHAR szClassName[50] = TEXT("OGL_CLASS"); // setup window class g_windClass.lpszClassName = szClassName; // Set the name of the Class g_windClass.lpfnWndProc = (WNDPROC)WndProc; g_windClass.hInstance = g_hInstance; // Use this module for the module handle g_windClass.hCursor = LoadCursor(NULL, IDC_ARROW);// Pick the default mouse cursor g_windClass.hIcon = LoadIcon(NULL, IDI_WINLOGO);// Pick the default windows icons g_windClass.hbrBackground = NULL; // No Background g_windClass.lpszMenuName = NULL; // No menu for this window g_windClass.style = CS_HREDRAW | CS_OWNDC | // set styles for this class, specifically to catch CS_VREDRAW; // window redraws, unique DC, and resize g_windClass.cbClsExtra = 0; // Extra class memory g_windClass.cbWndExtra = 0; // Extra window memory // Register the newly defined class if(!RegisterClass( &g_windClass )) bRetVal = false; dwExtStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; dwWindStyle = WS_OVERLAPPEDWINDOW; ShowCursor(TRUE); g_windowRect.left = nWindowX; g_windowRect.right = nWindowX + nWidth; g_windowRect.top = nWindowY; g_windowRect.bottom = nWindowY + nHeight; // Setup window width and height AdjustWindowRectEx(&g_windowRect, dwWindStyle, FALSE, dwExtStyle); //Adjust for adornments int nWindowWidth = g_windowRect.right - g_windowRect.left; int nWindowHeight = g_windowRect.bottom - g_windowRect.top; // Create window g_hWnd = CreateWindowEx(dwExtStyle, // Extended style szClassName, // class name szWindowName, // window name dwWindStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,// window stlye nWindowX, // window position, x nWindowY, // window position, y nWindowWidth, // height nWindowHeight, // width NULL, // Parent window NULL, // menu g_hInstance, // instance NULL); // pass this to WM_CREATE // now that we have a window, setup the pixel format descriptor g_hDC = GetDC(g_hWnd); // Set a dummy pixel format so that we can get access to wgl functions SetPixelFormat( g_hDC, 1,&pfd); // Create OGL context and make it current g_hRC = wglCreateContext( g_hDC ); wglMakeCurrent( g_hDC, g_hRC ); if (g_hDC == 0 || g_hDC == 0) { bRetVal = false; printf("!!! An error occured creating an OpenGL window.\n"); } // Setup GLEW which loads OGL function pointers GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ bRetVal = false; printf("Error: %s\n", glewGetErrorString(err)); } const GLubyte *oglVersion = glGetString(GL_VERSION); printf("This system supports OpenGL Version %s.\n", oglVersion); // Now that extensions are setup, delete window and start over picking a real format. wglMakeCurrent(NULL, NULL); wglDeleteContext(g_hRC); ReleaseDC(g_hWnd, g_hDC); DestroyWindow(g_hWnd); // Create the window again g_hWnd = CreateWindowEx(dwExtStyle, // Extended style szClassName, // class name szWindowName, // window name dwWindStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,// window stlye nWindowX, // window position, x nWindowY, // window position, y nWindowWidth, // height nWindowHeight, // width NULL, // Parent window NULL, // menu g_hInstance, // instance NULL); // pass this to WM_CREATE g_hDC = GetDC(g_hWnd); int nPixCount = 0; // Specify the important attributes we care about int pixAttribs[] = { WGL_SUPPORT_OPENGL_ARB, 1, // Must support OGL rendering WGL_DRAW_TO_WINDOW_ARB, 1, // pf that can run a window WGL_ACCELERATION_ARB, 1, // must be HW accelerated WGL_RED_BITS_ARB, 8, // 8 bits of red precision in window WGL_GREEN_BITS_ARB, 8, // 8 bits of green precision in window WGL_BLUE_BITS_ARB, 8, // 8 bits of blue precision in window WGL_DEPTH_BITS_ARB, 16, // 16 bits of depth precision for window WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, // pf should be RGBA type 0}; // NULL termination // Ask OpenGL to find the most relevant format matching our attribs // Only get one format back. wglChoosePixelFormatARB(g_hDC, &pixAttribs[0], NULL, 1, &nPixelFormat, (UINT*)&nPixCount); if(nPixelFormat == -1) { // Couldn't find a format, perhaps no 3D HW or drivers are installed g_hDC = 0; g_hDC = 0; bRetVal = false; printf("!!! An error occurred trying to find a pixel format with the requested attribs.\n"); } else { // Got a format, now set it as the current one SetPixelFormat( g_hDC, nPixelFormat, &pfd ); GLint attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 3, 0 }; g_hRC = wglCreateContextAttribsARB(g_hDC, 0, attribs); if (g_hRC == NULL) { printf("!!! Could not create an OpenGL 3.3 context.\n"); attribs[3] = 2; g_hRC = wglCreateContextAttribsARB(g_hDC, 0, attribs); if (g_hRC == NULL) { printf("!!! Could not create an OpenGL 3.2 context.\n"); attribs[3] = 1; g_hRC = wglCreateContextAttribsARB(g_hDC, 0, attribs); if (g_hRC == NULL) { printf("!!! Could not create an OpenGL 3.1 context.\n"); attribs[3] = 0; g_hRC = wglCreateContextAttribsARB(g_hDC, 0, attribs); if (g_hRC == NULL) { printf("!!! Could not create an OpenGL 3.0 context.\n"); printf("!!! OpenGL 3.0 and higher are not supported on this system.\n"); } } } } wglMakeCurrent( g_hDC, g_hRC ); } if (g_hDC == 0 || g_hDC == 0) { bRetVal = false; printf("!!! An error occured creating an OpenGL window.\n"); } // If everything went as planned, display the window if( bRetVal ) { ShowWindow( g_hWnd, SW_SHOW ); SetForegroundWindow( g_hWnd ); SetFocus( g_hWnd ); g_ContinueRendering = true; } return bRetVal; }
bool CWin32Workspace::CreateBestPixelFormat(PIXELFORMATDESCRIPTOR & pfd) { // Creating the Dummy window (test FSAA) HWND DummyHwnd = NULL; HDC DummyHdc = NULL; GLuint TestFormat = 0; char szDummyClass[MAX_LOADSTRING]; LoadString(mModuleHandle, IDS_DUMMYCLASS, szDummyClass, MAX_LOADSTRING); DummyHwnd = CreateWindowEx(NULL, szDummyClass, "Dummy", WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, NULL, NULL, mModuleHandle, NULL); if(!DummyHwnd) NOVA_EXP("CWin32Workspace::CreateBestPixelFormat - Can not create dummy window(", BAD_OPERATION); DummyHdc = GetDC(DummyHwnd); if(!DummyHdc) NOVA_EXP("CWin32Workspace::CreateBestPixelFormat - Can not get HDC from dummy window!", BAD_OPERATION); CWGLContext DummyContext(DummyHdc); TestFormat = ChoosePixelFormat(DummyHdc, &pfd); DummyContext.CreateRenderContext(&pfd, TestFormat); DummyContext.SetCurrent(); // Starting wgl if(!mSupport->GetState()) { dynamic_cast<CWGLSupport *>(mSupport)->InitGLExtentions(); dynamic_cast<CWGLSupport *>(mSupport)->InitWGLExtensions(DummyContext.GetDeviceContext()); } // Setting multisumple options if(mMetrics.FSAA > 1) { nstring e1("WGL_ARB_multisample"), e2("WGL_ARB_pixel_format"), e3("WGL_EXT_framebuffer_sRGB"); if(mSupport->CheckExtention(e1) && mSupport->CheckExtention(e2)) { bool useHwGamma = false; // Use WGL to test extended caps (multisample, sRGB) stl<int>::vector attribList; attribList.push_back(WGL_DRAW_TO_WINDOW_ARB); attribList.push_back(GL_TRUE); attribList.push_back(WGL_SUPPORT_OPENGL_ARB); attribList.push_back(GL_TRUE); attribList.push_back(WGL_DOUBLE_BUFFER_ARB); attribList.push_back(GL_TRUE); attribList.push_back(WGL_SAMPLE_BUFFERS_ARB); attribList.push_back(GL_TRUE); attribList.push_back(WGL_ACCELERATION_ARB); attribList.push_back(WGL_FULL_ACCELERATION_ARB); attribList.push_back(WGL_COLOR_BITS_ARB); attribList.push_back(pfd.cColorBits); attribList.push_back(WGL_ALPHA_BITS_ARB); attribList.push_back(pfd.cAlphaBits); attribList.push_back(WGL_DEPTH_BITS_ARB); attribList.push_back(24); attribList.push_back(WGL_STENCIL_BITS_ARB); attribList.push_back(8); attribList.push_back(WGL_SAMPLES_ARB); attribList.push_back(mMetrics.FSAA); if (useHwGamma && mSupport->CheckExtention(e3)) { attribList.push_back(WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT); attribList.push_back(GL_TRUE); } // terminator attribList.push_back(0); GLuint numformats; GLint format; int valid = wglChoosePixelFormatARB(DummyContext.GetDeviceContext(), &(attribList[0]), NULL, 1, &format, &numformats); if(valid && numformats > 0) { mBestPixelFormat = format; mBestFormatFinded = true; nstring str("Find compatible best pixel format: 0x"); str.append(CStringUtils::IntTo16xString(mBestPixelFormat)); LOG_MESSAGE(str); } else { mBestPixelFormat = TestFormat; mBestFormatFinded = false; nstring str("CWin32Workspace::CreateBestPixelFormat: Can not find compatible best pixel format,\n using simple format.. 0x"); str.append(CStringUtils::IntTo16xString(mBestPixelFormat)); LOG_MESSAGE(str); } } else { mBestPixelFormat = TestFormat; mBestFormatFinded = false; nstring str("CWin32Workspace::CreateBestPixelFormat: Can not find compatible best pixel format\n (extention WGL_ARB_multisample not supported) using simple format.. 0x"); str.append(CStringUtils::IntTo16xString(mBestPixelFormat)); LOG_MESSAGE(str); } } else mBestPixelFormat = TestFormat; DummyContext.EndCurrent(); DummyContext.DestroyThisContext(); ReleaseDC(DummyHwnd, DummyContext.GetDeviceContext()); DestroyWindow(DummyHwnd); DummyHwnd = NULL; return true; }
// this is a wrapper around wglChoosePixelFormatARB(): returns the pixel format // index matching the given attributes on success or 0 on failure static int ChoosePixelFormatARB(HDC hdc, const int *attribList) { if ( !wxGLCanvas::IsExtensionSupported("WGL_ARB_multisample") ) return 0; typedef BOOL (WINAPI * wglChoosePixelFormatARB_t) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats ); wxDEFINE_WGL_FUNC(wglChoosePixelFormatARB); if ( !wglChoosePixelFormatARB ) return 0; // should not occur if extension is supported int iAttributes[128]; int dst = 0; // index in iAttributes array #define ADD_ATTR(attr, value) \ iAttributes[dst++] = attr; iAttributes[dst++] = value ADD_ATTR( WGL_DRAW_TO_WINDOW_ARB, GL_TRUE ); ADD_ATTR( WGL_SUPPORT_OPENGL_ARB, GL_TRUE ); ADD_ATTR( WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB ); if ( !attribList ) { ADD_ATTR( WGL_COLOR_BITS_ARB, 24 ); ADD_ATTR( WGL_ALPHA_BITS_ARB, 8 ); ADD_ATTR( WGL_DEPTH_BITS_ARB, 16 ); ADD_ATTR( WGL_STENCIL_BITS_ARB, 0 ); ADD_ATTR( WGL_DOUBLE_BUFFER_ARB, GL_TRUE ); ADD_ATTR( WGL_SAMPLE_BUFFERS_ARB, GL_TRUE ); ADD_ATTR( WGL_SAMPLES_ARB, 4 ); } else // have custom attributes { #define ADD_ATTR_VALUE(attr) ADD_ATTR(attr, attribList[src++]) int src = 0; while ( attribList[src] ) { switch ( attribList[src++] ) { case WX_GL_RGBA: ADD_ATTR( WGL_COLOR_BITS_ARB, 24 ); ADD_ATTR( WGL_ALPHA_BITS_ARB, 8 ); break; case WX_GL_BUFFER_SIZE: ADD_ATTR_VALUE( WGL_COLOR_BITS_ARB); break; case WX_GL_LEVEL: if ( attribList[src] > 0 ) { ADD_ATTR( WGL_NUMBER_OVERLAYS_ARB, 1 ); } else if ( attribList[src] <0 ) { ADD_ATTR( WGL_NUMBER_UNDERLAYS_ARB, 1 ); } //else: ignore it src++; // skip the value in any case break; case WX_GL_DOUBLEBUFFER: ADD_ATTR( WGL_DOUBLE_BUFFER_ARB, GL_TRUE ); break; case WX_GL_STEREO: ADD_ATTR( WGL_STEREO_ARB, GL_TRUE ); break; case WX_GL_AUX_BUFFERS: ADD_ATTR_VALUE( WGL_AUX_BUFFERS_ARB ); break; case WX_GL_MIN_RED: ADD_ATTR_VALUE( WGL_RED_BITS_ARB ); break; case WX_GL_MIN_GREEN: ADD_ATTR_VALUE( WGL_GREEN_BITS_ARB ); break; case WX_GL_MIN_BLUE: ADD_ATTR_VALUE( WGL_BLUE_BITS_ARB ); break; case WX_GL_MIN_ALPHA: ADD_ATTR_VALUE( WGL_ALPHA_BITS_ARB ); break; case WX_GL_DEPTH_SIZE: ADD_ATTR_VALUE( WGL_DEPTH_BITS_ARB ); break; case WX_GL_STENCIL_SIZE: ADD_ATTR_VALUE( WGL_STENCIL_BITS_ARB ); break; case WX_GL_MIN_ACCUM_RED: ADD_ATTR_VALUE( WGL_ACCUM_RED_BITS_ARB ); break; case WX_GL_MIN_ACCUM_GREEN: ADD_ATTR_VALUE( WGL_ACCUM_GREEN_BITS_ARB ); break; case WX_GL_MIN_ACCUM_BLUE: ADD_ATTR_VALUE( WGL_ACCUM_BLUE_BITS_ARB ); break; case WX_GL_MIN_ACCUM_ALPHA: ADD_ATTR_VALUE( WGL_ACCUM_ALPHA_BITS_ARB ); break; case WX_GL_SAMPLE_BUFFERS: ADD_ATTR_VALUE( WGL_SAMPLE_BUFFERS_ARB ); break; case WX_GL_SAMPLES: ADD_ATTR_VALUE( WGL_SAMPLES_ARB ); break; } } #undef ADD_ATTR_VALUE } #undef ADD_ATTR iAttributes[dst++] = 0; int pf; UINT numFormats = 0; if ( !wglChoosePixelFormatARB(hdc, iAttributes, NULL, 1, &pf, &numFormats) ) { wxLogLastError(_T("wglChoosePixelFormatARB")); return 0; } return pf; }
int glwtInitWGL(const GLWTConfig *config) { UINT num_formats; int pixel_attribs[] = { WGL_RED_BITS_ARB, config ? config->red_bits : 0, WGL_GREEN_BITS_ARB, config ? config->green_bits : 0, WGL_BLUE_BITS_ARB, config ? config->blue_bits : 0, WGL_ALPHA_BITS_ARB, config ? config->alpha_bits : 0, WGL_DEPTH_BITS_ARB, config ? config->depth_bits : 0, WGL_STENCIL_BITS_ARB, config ? config->stencil_bits : 0, WGL_SAMPLES_ARB, config ? config->samples : 0, WGL_SAMPLE_BUFFERS_ARB, config ? config->sample_buffers : 0, WGL_SUPPORT_OPENGL_ARB, 1, WGL_DOUBLE_BUFFER_ARB, 1, WGL_DRAW_TO_WINDOW_ARB, 1, 0, 0 }; HGLRC old_context = 0, temp_context = 0; HDC old_hdc = 0; glwt.api = config ? config->api : GLWT_API_ANY; glwt.api_version_major = config ? config->api_version_major : 0; glwt.api_version_minor = config ? config->api_version_minor : 0; old_context = wglGetCurrentContext(); old_hdc = wglGetCurrentDC(); temp_context = wglCreateContext(glwt.win32.dummy_hdc); if(!temp_context) { glwtWin32Error("wglCreateContext failed"); goto error; } if(!wglMakeCurrent(glwt.win32.dummy_hdc, temp_context)) { glwtWin32Error("wglMakeCurrent failed"); goto error; } if(glxwInitWGL() != 0) goto error; // Required: WGL_ARB_extensions_string, WGL_ARB_pixel_format, WGL_ARB_multisample, WGL_ARB_make_current_read, WGL_EXT_swap_control if(!wglChoosePixelFormatARB(glwt.win32.dummy_hdc, pixel_attribs, NULL, 1, &glwt.wgl.pixel_format, &num_formats) || num_formats == 0) { glwtWin32Error("wglChoosePixelFormatARB failed"); goto error; } wglMakeCurrent(old_hdc, old_context); wglDeleteContext(temp_context); return 0; error: wglMakeCurrent(old_hdc, old_context); if(temp_context) wglDeleteContext(temp_context); glwtQuitWGL(); return -1; }
bool setPixelFormat (const OpenGLPixelFormat& pixelFormat) { makeActive(); PIXELFORMATDESCRIPTOR pfd; initialisePixelFormatDescriptor (pfd, pixelFormat); int format = 0; if (wglChoosePixelFormatARB != nullptr) { int atts[64]; int n = 0; atts[n++] = WGL_DRAW_TO_WINDOW_ARB; atts[n++] = GL_TRUE; atts[n++] = WGL_SUPPORT_OPENGL_ARB; atts[n++] = GL_TRUE; atts[n++] = WGL_DOUBLE_BUFFER_ARB; atts[n++] = GL_TRUE; atts[n++] = WGL_PIXEL_TYPE_ARB; atts[n++] = WGL_TYPE_RGBA_ARB; atts[n++] = WGL_COLOR_BITS_ARB; atts[n++] = pfd.cColorBits; atts[n++] = WGL_RED_BITS_ARB; atts[n++] = pixelFormat.redBits; atts[n++] = WGL_GREEN_BITS_ARB; atts[n++] = pixelFormat.greenBits; atts[n++] = WGL_BLUE_BITS_ARB; atts[n++] = pixelFormat.blueBits; atts[n++] = WGL_ALPHA_BITS_ARB; atts[n++] = pixelFormat.alphaBits; atts[n++] = WGL_DEPTH_BITS_ARB; atts[n++] = pixelFormat.depthBufferBits; atts[n++] = WGL_STENCIL_BITS_ARB; atts[n++] = pixelFormat.stencilBufferBits; atts[n++] = WGL_ACCUM_RED_BITS_ARB; atts[n++] = pixelFormat.accumulationBufferRedBits; atts[n++] = WGL_ACCUM_GREEN_BITS_ARB; atts[n++] = pixelFormat.accumulationBufferGreenBits; atts[n++] = WGL_ACCUM_BLUE_BITS_ARB; atts[n++] = pixelFormat.accumulationBufferBlueBits; atts[n++] = WGL_ACCUM_ALPHA_BITS_ARB; atts[n++] = pixelFormat.accumulationBufferAlphaBits; if (pixelFormat.multisamplingLevel > 0 && OpenGLHelpers::isExtensionSupported ("GL_ARB_multisample")) { atts[n++] = WGL_SAMPLE_BUFFERS_ARB; atts[n++] = 1; atts[n++] = WGL_SAMPLES_ARB; atts[n++] = pixelFormat.multisamplingLevel; } atts[n++] = 0; jassert (n <= numElementsInArray (atts)); UINT formatsCount = 0; wglChoosePixelFormatARB (dc, atts, nullptr, 1, &format, &formatsCount); } if (format == 0) format = ChoosePixelFormat (dc, &pfd); if (format != 0) { makeInactive(); // win32 can't change the pixel format of a window, so need to delete the // old one and create a new one.. jassert (nativeWindow != 0); ReleaseDC ((HWND) nativeWindow->getNativeHandle(), dc); nativeWindow = nullptr; createNativeWindow(); if (SetPixelFormat (dc, format, &pfd)) { wglDeleteContext (renderContext); renderContext = wglCreateContext (dc); jassert (renderContext != 0); return renderContext != 0; } } return false; }
void Win32PBuffer::createPBuffer() { // Process format int bits=0; bool isFloat=false; #if 0 bool hasAlpha=true; #endif switch(mFormat) { case PCT_BYTE: bits=8; isFloat=false; break; case PCT_SHORT: bits=16; isFloat=false; break; case PCT_FLOAT16: bits=16; isFloat=true; break; case PCT_FLOAT32: bits=32; isFloat=true; break; default: break; }; LogManager::getSingleton().logMessage( " Win32PBuffer::Creating PBuffer of format bits="+ StringConverter::toString(bits)+ " float="+StringConverter::toString(isFloat) ); HDC old_hdc = wglGetCurrentDC(); HGLRC old_context = wglGetCurrentContext(); // Bind to RGB or RGBA texture int bttype = 0; #if 0 if(mUseBind) { // Only provide bind type when actually binding bttype = PixelUtil::hasAlpha(mInternalFormat)? WGL_BIND_TO_TEXTURE_RGBA_ARB : WGL_BIND_TO_TEXTURE_RGB_ARB; } int texformat = hasAlpha? WGL_TEXTURE_RGBA_ARB : WGL_TEXTURE_RGB_ARB; #endif // Make a float buffer? int pixeltype = isFloat? WGL_TYPE_RGBA_FLOAT_ARB: WGL_TYPE_RGBA_ARB; int attrib[] = { WGL_RED_BITS_ARB,bits, WGL_GREEN_BITS_ARB,bits, WGL_BLUE_BITS_ARB,bits, WGL_ALPHA_BITS_ARB,bits, WGL_STENCIL_BITS_ARB,1, WGL_DEPTH_BITS_ARB,15, WGL_DRAW_TO_PBUFFER_ARB,true, WGL_SUPPORT_OPENGL_ARB,true, WGL_PIXEL_TYPE_ARB,pixeltype, //WGL_DOUBLE_BUFFER_ARB,true, //WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB, // Make sure it is accelerated bttype,true, // must be last, as bttype can be zero 0 }; int pattrib_default[] = { 0 }; #if 0 int pattrib_bind[] = { WGL_TEXTURE_FORMAT_ARB, texformat, WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, WGL_PBUFFER_LARGEST_ARB, true, 0 }; #endif int format; unsigned int count; // Choose suitable pixel format wglChoosePixelFormatARB(old_hdc,attrib,NULL,1,&format,&count); if(count == 0) OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "wglChoosePixelFormatARB() failed", " Win32PBuffer::createPBuffer"); // Analyse pixel format const int piAttributes[]={ WGL_RED_BITS_ARB,WGL_GREEN_BITS_ARB,WGL_BLUE_BITS_ARB,WGL_ALPHA_BITS_ARB, WGL_DEPTH_BITS_ARB,WGL_STENCIL_BITS_ARB }; int piValues[sizeof(piAttributes)/sizeof(const int)]; wglGetPixelFormatAttribivARB(old_hdc,format,0,sizeof(piAttributes)/sizeof(const int),piAttributes,piValues); LogManager::getSingleton().stream() << " Win32PBuffer::PBuffer -- Chosen pixel format rgba=" << piValues[0] << "," << piValues[1] << "," << piValues[2] << "," << piValues[3] << " depth=" << piValues[4] << " stencil=" << piValues[5]; mPBuffer = wglCreatePbufferARB(old_hdc,format,mWidth,mHeight,pattrib_default); if(!mPBuffer) OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "wglCreatePbufferARB() failed", " Win32PBuffer::createPBuffer"); mHDC = wglGetPbufferDCARB(mPBuffer); if(!mHDC) { wglDestroyPbufferARB(mPBuffer); OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "wglGetPbufferDCARB() failed", " Win32PBuffer::createPBuffer"); } mGlrc = wglCreateContext(mHDC); if(!mGlrc) { wglReleasePbufferDCARB(mPBuffer,mHDC); wglDestroyPbufferARB(mPBuffer); OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "wglCreateContext() failed", " Win32PBuffer::createPBuffer"); } if(!wglShareLists(old_context,mGlrc)) { wglDeleteContext(mGlrc); wglReleasePbufferDCARB(mPBuffer,mHDC); wglDestroyPbufferARB(mPBuffer); OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "wglShareLists() failed", " Win32PBuffer::createPBuffer"); } // Query real width and height int iWidth, iHeight; wglQueryPbufferARB(mPBuffer, WGL_PBUFFER_WIDTH_ARB, &iWidth); wglQueryPbufferARB(mPBuffer, WGL_PBUFFER_HEIGHT_ARB, &iHeight); mWidth = iWidth; mHeight = iHeight; LogManager::getSingleton().stream() << "Win32RenderTexture::PBuffer created -- Real dimensions " << mWidth << "x" << mHeight; }
// 启动 OpenGL 后, 才能调用它的扩展函数来设置 multi-sampling 功能. // 还需要重新打开新的窗口来使用 multi-sampling 模式, 不能使用原来的窗口. static bool SetPixelformatEX(HCoreDeviceSpec *pSpec) { HWND hWnd = HCoreGetWindowHandleWin32(); g_hDC = GetDC(hWnd); PIXELFORMATDESCRIPTOR pfd; ZeroMemory(&pfd, sizeof(pfd)); pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); pfd.nVersion = 1; pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_TYPE_RGBA; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cDepthBits = 24; // 24 bits zbuffer pfd.cStencilBits = 8; // 8 bits stencil buffer pfd.iLayerType = PFD_MAIN_PLANE; // main layer int pixelformat = ChoosePixelFormat(g_hDC, &pfd); if ( pixelformat == 0 ) { return false; } if ( SetPixelFormat(g_hDC, pixelformat, &pfd) == FALSE) { ReleaseDC(hWnd, g_hDC); return false; } g_hGLRC = wglCreateContext(g_hDC); wglMakeCurrent(g_hDC, g_hGLRC); if (!wglChoosePixelFormatARB) { wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB"); } if ( !wglChoosePixelFormatARB ) { printf("OpenGL Display driver does not support wglChoosePixelFormatARB function\n"); return false; } int iAttributes[] = { WGL_DRAW_TO_WINDOW_ARB,GL_TRUE, WGL_SUPPORT_OPENGL_ARB,GL_TRUE, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, WGL_COLOR_BITS_ARB,24, WGL_ALPHA_BITS_ARB,8, WGL_DEPTH_BITS_ARB,24, WGL_STENCIL_BITS_ARB,8, WGL_DOUBLE_BUFFER_ARB,GL_TRUE, WGL_SAMPLE_BUFFERS_ARB,GL_TRUE, WGL_SAMPLES_ARB, pSpec->m_iMultiSamples, 0,0}; float fAttributes[] = {0,0}; UINT numFormats = 0; BOOL valid = wglChoosePixelFormatARB(g_hDC, iAttributes, fAttributes,1, &pixelformat, &numFormats); if (!valid && numFormats==0) { return false; } DescribePixelFormat(g_hDC, pixelformat, sizeof(pfd), &pfd); if ( g_hGLRC && g_hDC ) { wglMakeCurrent(g_hDC, NULL); wglDeleteContext(g_hGLRC); g_hGLRC = NULL; ReleaseDC(hWnd, g_hDC); g_hDC = NULL; DestroyWindow(hWnd); MSG msg; while(GetMessage(&msg, NULL, 0, 0)!=0) {} } HCoreCreateWindow(-1, -1, -1, -1, "OpenGL"); hWnd = HCoreGetWindowHandleWin32(); g_hDC = GetDC(hWnd); if ( SetPixelFormat(g_hDC, pixelformat, &pfd)==FALSE) { ErrorMessage("SetPixelFormatEX"); ReleaseDC(hWnd, g_hDC); return false; } g_hGLRC = wglCreateContext(g_hDC); wglMakeCurrent(g_hDC, g_hGLRC); return true; }
bool OpenGLApp::initAPI(){ if (screen >= GetSystemMetrics(SM_CMONITORS)) screen = 0; int monitorCounter = screen; EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM) &monitorCounter); // TODO: Use this when saving out position? // HMONITOR hMonitor = MonitorFromWindow(m_handle->hWnd, MONITOR_DEFAULTTOPRIMARY); DWORD flags = WS_CLIPCHILDREN | WS_CLIPSIBLINGS; int x, y; x = monInfo.rcMonitor.left; y = monInfo.rcMonitor.top; device.cb = sizeof(device); //TODO: Monitor count is not equal to device count? EnumDisplayDevices(NULL, 0/*screen*/, &device, 0); DEVMODE dm, tdm; memset(&dm, 0, sizeof(dm)); dm.dmSize = sizeof(dm); dm.dmBitsPerPel = colorBits; dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY; dm.dmPelsWidth = fullscreenWidth; dm.dmPelsHeight = fullscreenHeight; dm.dmDisplayFrequency = 60; // Find a suitable fullscreen format int i = 0; int targetHz = 85; char str[128]; resolution->clear(); while (EnumDisplaySettings((const char *) device.DeviceName, i, &tdm)){ if (int(tdm.dmBitsPerPel) == colorBits && tdm.dmPelsWidth >= 640 && tdm.dmPelsHeight >= 480){ sprintf(str, "%dx%d", tdm.dmPelsWidth, tdm.dmPelsHeight); int index = resolution->addItemUnique(str); if (int(tdm.dmPelsWidth) == fullscreenWidth && int(tdm.dmPelsHeight) == fullscreenHeight){ if (abs(int(tdm.dmDisplayFrequency) - targetHz) < abs(int(dm.dmDisplayFrequency) - targetHz)){ dm = tdm; } resolution->selectItem(index); } } i++; } if (fullscreen){ //TODO: Select correct monitor? //dm.dmFields |= DM_POSITION ; //dm.dmPosition.x = x; //dm.dmPosition.y = y; if (ChangeDisplaySettingsEx((const char *) device.DeviceName, &dm, NULL, CDS_FULLSCREEN, NULL) == DISP_CHANGE_SUCCESSFUL){ flags |= WS_POPUP; captureMouse(!configDialog->isVisible()); } else { ErrorMsg("Couldn't set fullscreen mode"); fullscreen = false; } } sprintf(str, "%s (%dx%d)", getTitle(), width, height); if (!fullscreen){ flags |= WS_OVERLAPPEDWINDOW; RECT wRect; wRect.left = 0; wRect.right = width; wRect.top = 0; wRect.bottom = height; AdjustWindowRect(&wRect, flags, FALSE); width = min(wRect.right - wRect.left, monInfo.rcWork.right - monInfo.rcWork.left); height = min(wRect.bottom - wRect.top, monInfo.rcWork.bottom - monInfo.rcWork.top); x = (monInfo.rcWork.left + monInfo.rcWork.right - width ) / 2; y = (monInfo.rcWork.top + monInfo.rcWork.bottom - height) / 2; } hwnd = CreateWindow("Humus", str, flags, x, y, width, height, HWND_DESKTOP, NULL, hInstance, NULL); PIXELFORMATDESCRIPTOR pfd = { sizeof (PIXELFORMATDESCRIPTOR), 1, PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, PFD_TYPE_RGBA, colorBits, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, depthBits, stencilBits, 0, PFD_MAIN_PLANE, 0, 0, 0, 0 }; hdc = GetDC(hwnd); int iAttribs[] = { WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, WGL_DOUBLE_BUFFER_ARB, GL_TRUE, WGL_RED_BITS_ARB, 8, WGL_GREEN_BITS_ARB, 8, WGL_BLUE_BITS_ARB, 8, WGL_ALPHA_BITS_ARB, (colorBits > 24)? 8 : 0, WGL_DEPTH_BITS_ARB, depthBits, WGL_STENCIL_BITS_ARB, stencilBits, 0 }; int pixelFormats[256]; int bestFormat = 0; int bestSamples = 0; uint nPFormats; if (wgl_ext_ARB_pixel_format && wglChoosePixelFormatARB(hdc, iAttribs, NULL, elementsOf(pixelFormats), pixelFormats, &nPFormats) && nPFormats > 0){ int minDiff = 0x7FFFFFFF; int attrib = WGL_SAMPLES_ARB; int samples; // Find a multisample format as close as possible to the requested for (uint i = 0; i < nPFormats; i++){ wglGetPixelFormatAttribivARB(hdc, pixelFormats[i], 0, 1, &attrib, &samples); int diff = abs(antiAliasSamples - samples); if (diff < minDiff){ minDiff = diff; bestFormat = i; bestSamples = samples; } } } else { pixelFormats[0] = ChoosePixelFormat(hdc, &pfd); } antiAliasSamples = bestSamples; SetPixelFormat(hdc, pixelFormats[bestFormat], &pfd); if(wgl_ext_ARB_create_context) { glContext = wglCreateContextAttribsARB(hdc, 0, 0); } else { glContext = wglCreateContext(hdc); } wglMakeCurrent(hdc, glContext); ogl_LoadFunctions(); wgl_LoadFunctions(hdc); if (wgl_ext_ARB_multisample && antiAliasSamples > 0){ glEnable(GL_MULTISAMPLE); } if (fullscreen) captureMouse(!configDialog->isVisible()); renderer = new OpenGLRenderer(hdc, glContext); renderer->setViewport(width, height); antiAlias->selectItem(antiAliasSamples / 2); linearClamp = renderer->addSamplerState(LINEAR, CLAMP, CLAMP, CLAMP); defaultFont = renderer->addFont("../Textures/Fonts/Future.dds", "../Textures/Fonts/Future.font", linearClamp); blendSrcAlpha = renderer->addBlendState(SRC_ALPHA, ONE_MINUS_SRC_ALPHA); noDepthTest = renderer->addDepthState(false, false); noDepthWrite = renderer->addDepthState(true, false); cullNone = renderer->addRasterizerState(CULL_NONE); cullBack = renderer->addRasterizerState(CULL_BACK); cullFront = renderer->addRasterizerState(CULL_FRONT); return true; }
bool cPBuffer::Init(unsigned int alWidth,unsigned int alHeight, cColor aCol) { #ifdef WIN32 unsigned int lFormatNum=0; int lFormat=0; mlWidth = alWidth; mlHeight = alHeight; HDC CurrentHdc = wglGetCurrentDC(); HGLRC CurrentGGlRc = wglGetCurrentContext(); //Set the pixel format: wglChoosePixelFormatARB(CurrentHdc, &mvAttribFormat[0], NULL, 1, &lFormat, &lFormatNum); if(lFormatNum==0){ Error("Couldn't find any pixel format!\n"); return false; } //Create the buffer mPBuffer = wglCreatePbufferARB(CurrentHdc, lFormat, mlWidth, mlHeight, &mvAttribBuffer[0]); if (!mPBuffer) { int err = GetLastError(); Error("pbuffer creation error!\n"); return false; } //Get the Device Context mDeviceContext = wglGetPbufferDCARB(mPBuffer); if(!mDeviceContext){ Error("Some DC error!\n"); } //Get the GL Context mGLContext = wglCreateContext(mDeviceContext); if(!mGLContext){ Error("Some GLRC error!\n"); } if(mbShareObjects){ if(!wglShareLists(CurrentGGlRc, mGLContext)) { Error("Error sharing lists.\n"); } } //Check the real dimensions of the PBuffer wglQueryPbufferARB(mPBuffer, WGL_PBUFFER_WIDTH_ARB, &mlWidth); wglQueryPbufferARB(mPBuffer, WGL_PBUFFER_HEIGHT_ARB, &mlHeight); //Init some GL stuff with the Buffer. #ifdef WIN32 HDC OldHDC = wglGetCurrentDC(); HGLRC OldGLRC = wglGetCurrentContext(); #endif MakeCurrentContext(); if(mbShareObjects) { cLowLevelGraphicsSDL* pSDLGfx = static_cast<cLowLevelGraphicsSDL*>(mpLowLevelGraphics); pSDLGfx->SetupGL(); } mpLowLevelGraphics->SetClearColor(aCol); mpLowLevelGraphics->ClearScreen(); wglMakeCurrent(OldHDC,OldGLRC); #elif defined(__linux__) return false; #endif return true; }
bool PBUFFER::Init( int newWidth, int newHeight, const int * attribIList, const float * attribFList, const int * flags) { //Check for pbuffer support if( !GLEE_WGL_ARB_extensions_string || !GLEE_WGL_ARB_pixel_format || !GLEE_WGL_ARB_pbuffer) { LOG::Instance()->OutputError("Extension required for pBuffer unsupported"); return false; } //set class's member variables width=newWidth; height=newHeight; //Get the current device context HDC hCurrentDC=wglGetCurrentDC(); if(!hCurrentDC) { LOG::Instance()->OutputError("Unable to get current Device Context"); return false; } //choose pixel format GLint pixelFormat; unsigned int numFormats; if(!wglChoosePixelFormatARB(hCurrentDC, attribIList, attribFList, 1, &pixelFormat, &numFormats)) { LOG::Instance()->OutputError("Unable to find a pixel format for the pbuffer"); return false; } //Create the pbuffer hBuffer=wglCreatePbufferARB(hCurrentDC, pixelFormat, width, height, flags); if(!hBuffer) { LOG::Instance()->OutputError("Unable to create pbuffer"); return false; } //Get the pbuffer's device context hDC=wglGetPbufferDCARB(hBuffer); if(!hDC) { LOG::Instance()->OutputError("Unable to get pbuffer's device context"); return false; } //Create a rendering context for the pbuffer hRC=wglCreateContext(hDC); if(!hRC) { LOG::Instance()->OutputError("Unable to create pbuffer's rendering context"); return false; } //Set and output the actual pBuffer dimensions wglQueryPbufferARB(hBuffer, WGL_PBUFFER_WIDTH_ARB, &width); wglQueryPbufferARB(hBuffer, WGL_PBUFFER_HEIGHT_ARB, &height); LOG::Instance()->OutputSuccess("Pbuffer Created: (%d x %d)", width, height); return TRUE; //success! }
int CmnOGLOffscreen::init(void) { /* Fehlercodes: -1 = Unable to get address for wglGetExtensionsStringARB -2 = WGL_ARB_pbuffer extension was not found -3 = One or more WGL_ARB_pbuffer functions were not found -4 = WGL_ARB_pixel_format extension was not found -5 = One or more WGL_ARB_pixel_format functions were not found -6 = WGL_ARB_render_texture extension was not found -7 = One or more WGL_ARB_render_texture functions were not found -8 = Could not find an acceptable pixel format -9 = Could not create the p-buffer */ wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB"); char *ext = NULL; if( wglGetExtensionsStringARB ) ext = (char*)wglGetExtensionsStringARB( wglGetCurrentDC() ); else return -1; if( strstr( ext, "WGL_ARB_pbuffer" ) == NULL ) return -2; wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)wglGetProcAddress("wglCreatePbufferARB"); wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)wglGetProcAddress("wglGetPbufferDCARB"); wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)wglGetProcAddress("wglReleasePbufferDCARB"); wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)wglGetProcAddress("wglDestroyPbufferARB"); wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)wglGetProcAddress("wglQueryPbufferARB"); if( !wglCreatePbufferARB || !wglGetPbufferDCARB || !wglReleasePbufferDCARB ||!wglDestroyPbufferARB || !wglQueryPbufferARB ) return -3; if( strstr( ext, "WGL_ARB_pixel_format" ) == NULL ) return -4; wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB"); if( !wglChoosePixelFormatARB ) return -5; g_pbuffer.hPBuffer = NULL; g_pbuffer.nWidth = iWidth; g_pbuffer.nHeight = iHeight; int pf_attr[] = { WGL_SUPPORT_OPENGL_ARB, TRUE, // P-buffer will be used with OpenGL WGL_DRAW_TO_PBUFFER_ARB, TRUE, // Enable render to p-buffer WGL_BIND_TO_TEXTURE_RGBA_ARB, TRUE, // P-buffer will be used as a texture WGL_RED_BITS_ARB, 8, // At least 8 bits for RED channel WGL_GREEN_BITS_ARB, 8, // At least 8 bits for GREEN channel WGL_BLUE_BITS_ARB, 8, // At least 8 bits for BLUE channel WGL_ALPHA_BITS_ARB, 8, // At least 8 bits for ALPHA channel WGL_DEPTH_BITS_ARB, 16, // At least 16 bits for depth buffer WGL_DOUBLE_BUFFER_ARB, FALSE, // We don't require double buffering 0 // Zero terminates the list }; unsigned int count = 0; int pixelFormat; wglChoosePixelFormatARB( m_hgldc,(const int*)pf_attr, NULL, 1, &pixelFormat, &count); if( count == 0 ) return -8; g_pbuffer.hPBuffer = wglCreatePbufferARB( m_hgldc, pixelFormat, g_pbuffer.nWidth, g_pbuffer.nHeight, NULL/*pb_attr*/ ); g_pbuffer.hDC = wglGetPbufferDCARB( g_pbuffer.hPBuffer ); g_pbuffer.hRC = wglCreateContext( g_pbuffer.hDC ); if( !g_pbuffer.hPBuffer ) return -9; enable(); glShadeModel(GL_SMOOTH); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glViewport(0,0,iWidth,iHeight); glMatrixMode(GL_PROJECTION); glLoadIdentity(); double m_dAspect = (iHeight == 0) ? (double)iWidth : (double)iWidth/(double)iHeight; double m_dNearPlane = 0.0; double m_dFarPlane = 15.0; gluPerspective(45.0, m_dAspect, m_dNearPlane, m_dFarPlane); glMatrixMode(GL_MODELVIEW); disable(); return 1; }
bool COpenGLControl::InitOpenGL(HINSTANCE hInstance, HWND* a_hWnd, int iMajorVersion, int iMinorVersion, void (*a_ptrInitScene)(LPVOID), void (*a_ptrRenderScene)(LPVOID), void(*a_ptrReleaseScene)(LPVOID), LPVOID lpParam) { if(!InitGLEW(hInstance))return false; hWnd = a_hWnd; hDC = GetDC(*hWnd); bool bError = false; PIXELFORMATDESCRIPTOR pfd; if(iMajorVersion <= 2) { memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR)); pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); pfd.nVersion = 1; pfd.dwFlags = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = 32; pfd.cDepthBits = 32; pfd.iLayerType = PFD_MAIN_PLANE; int iPixelFormat = ChoosePixelFormat(hDC, &pfd); if (iPixelFormat == 0)return false; if(!SetPixelFormat(hDC, iPixelFormat, &pfd))return false; // Create the old style context (OpenGL 2.1 and before) hRC = wglCreateContext(hDC); if(hRC)wglMakeCurrent(hDC, hRC); else bError = true; } else if(WGLEW_ARB_create_context && WGLEW_ARB_pixel_format) { const int iPixelFormatAttribList[] = { WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, WGL_DOUBLE_BUFFER_ARB, GL_TRUE, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, WGL_COLOR_BITS_ARB, 32, WGL_DEPTH_BITS_ARB, 24, WGL_STENCIL_BITS_ARB, 8, 0 // End of attributes list }; int iContextAttribs[] = { WGL_CONTEXT_MAJOR_VERSION_ARB, iMajorVersion, WGL_CONTEXT_MINOR_VERSION_ARB, iMinorVersion, WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, 0 // End of attributes list }; int iPixelFormat, iNumFormats; wglChoosePixelFormatARB(hDC, iPixelFormatAttribList, NULL, 1, &iPixelFormat, (UINT*)&iNumFormats); // PFD seems to be only redundant parameter now if(!SetPixelFormat(hDC, iPixelFormat, &pfd))return false; hRC = wglCreateContextAttribsARB(hDC, 0, iContextAttribs); // If everything went OK if(hRC) wglMakeCurrent(hDC, hRC); else bError = true; } else bError = true; if(bError) { // Generate error messages char sErrorMessage[255], sErrorTitle[255]; sprintf_s(sErrorMessage, "OpenGL %d.%d is not supported! Please download latest GPU drivers!", iMajorVersion, iMinorVersion); //_s sprintf_s(sErrorTitle, "OpenGL %d.%d Not Supported", iMajorVersion, iMinorVersion); //_s MessageBox(*hWnd, sErrorMessage, sErrorTitle, MB_ICONINFORMATION); return false; } ptrRenderScene = a_ptrRenderScene; ptrInitScene = a_ptrInitScene; ptrReleaseScene = a_ptrReleaseScene; if(ptrInitScene != NULL)ptrInitScene(lpParam); return true; }
// Initializes OpenGL rendering context. If succeeds, returns true. // hInstance - application instance // a_hWnd - window to init OpenGL into // a_initScene - pointer to init function // a_renderScene - pointer to render function // a_releaseScene - optional parameter of release function bool COpenGLControl::InitOpenGL(HINSTANCE hInstance, HWND* a_hWnd, void (*a_InitScene)(LPVOID), void (*a_RenderScene)(LPVOID), void(*a_ReleaseScene)(LPVOID), LPVOID lpParam) { if(!InitGLEW(hInstance))return false; hWnd = a_hWnd; hDC = GetDC(*hWnd); bool bError = false; PIXELFORMATDESCRIPTOR pfd; // if we have access to these functions if(WGLEW_ARB_create_context && WGLEW_ARB_pixel_format) { const int iPixelFormatAttribList[] = { WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, // Enable OpenGL support WGL_DOUBLE_BUFFER_ARB, GL_TRUE, // and double buffer WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, WGL_COLOR_BITS_ARB, 32, WGL_DEPTH_BITS_ARB, 24, // Depth buffer size WGL_STENCIL_BITS_ARB, 8, 0 // End of attributes list }; int iContextAttribs[] = { WGL_CONTEXT_MAJOR_VERSION_ARB, 3, // OpenGL WGL_CONTEXT_MINOR_VERSION_ARB, 3, // version 3.3 WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, 0 // End of attributes list }; int iPixelFormat, iNumFormats; wglChoosePixelFormatARB(hDC, iPixelFormatAttribList, NULL, 1, &iPixelFormat, (UINT*)&iNumFormats); // PFD seems to be only redundant parameter now if(!SetPixelFormat(hDC, iPixelFormat, &pfd))return false; hRC = wglCreateContextAttribsARB(hDC, 0, iContextAttribs); // If everything went OK if(hRC) wglMakeCurrent(hDC, hRC); else bError = true; } else bError = true; if(bError) { // Generate error messages char sErrorMessage[255], sErrorTitle[255]; sprintf(sErrorMessage, "OpenGL 3.3 is not supported! Please download latest GPU drivers!"); sprintf(sErrorTitle, "OpenGL 3.3 Not Supported"); MessageBox(*hWnd, sErrorMessage, sErrorTitle, MB_ICONINFORMATION); return false; } RenderScene = a_RenderScene; InitScene = a_InitScene; ReleaseScene = a_ReleaseScene; if(InitScene != NULL)InitScene(lpParam); return true; }
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { static HWND shwnd; static HDC hdc; static HGLRC hglrc, hglrc_legacy; static Engine altEngine; static POINT center; static WSADATA wsadata; switch (message) { case WM_CREATE: WSAStartup(MAKEWORD(2, 2), &wsadata); AllocConsole(); RedirectIOToConsole(); SetTimer ( hwnd, TICK_TIMER, 16, NULL ); hdc = GetDC(hwnd); setupPixelFormat(hdc); #ifndef DIRECTX hglrc_legacy = wglCreateContext(hdc); wglMakeCurrent(hdc, hglrc_legacy); glewInit(); if(wglewIsSupported("WGL_ARB_create_context") == TRUE) { const int context[] = { WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 1, // WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, 0 }; const int pixelformat[] = { WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, WGL_DOUBLE_BUFFER_ARB, GL_TRUE, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, WGL_COLOR_BITS_ARB, 32, WGL_DEPTH_BITS_ARB, 24, WGL_STENCIL_BITS_ARB, 8, 0, }; int format; unsigned int num_formats; wglChoosePixelFormatARB(hdc, (int *)pixelformat, NULL, 1, &format, &num_formats); hglrc = wglCreateContextAttribsARB(hdc, 0, context); wglMakeCurrent(NULL,NULL); wglDeleteContext(hglrc_legacy); wglMakeCurrent(hdc, hglrc); } else { //opengl 2.0 hglrc = hglrc_legacy; } #endif shwnd = hwnd; altEngine.init(&shwnd, &hdc); return 0; case WMU_RENDER: altEngine.render(); return 0; case WM_TIMER: if (glGetError() != GL_NO_ERROR) { printf("GL_ERROR\n"); } switch(wParam) { case TICK_TIMER: altEngine.step(); break; } return 0; case WM_MOUSEMOVE: { int x, y; x = LOWORD(lParam); y = HIWORD(lParam); if ((x == center.x) && (y == center.y)) return 0; if ( altEngine.mousepos(x, y, x - center.x, y - center.y) ) { POINT screen = center; ClientToScreen(hwnd, &screen); SetCursorPos(screen.x, screen.y); } } return 0; case WM_LBUTTONDOWN: case WM_LBUTTONUP: { bool pressed = (message == WM_LBUTTONDOWN) ? true : false; altEngine.keypress("leftbutton", pressed); return 0; } case WM_MBUTTONDOWN: case WM_MBUTTONUP: { bool pressed = (message == WM_MBUTTONDOWN) ? true : false; altEngine.keypress("middlebutton", pressed); return 0; } case WM_RBUTTONDOWN: case WM_RBUTTONUP: { bool pressed = (message == WM_RBUTTONDOWN) ? true : false; altEngine.keypress("rightbutton", pressed); return 0; } case WM_KEYDOWN: case WM_KEYUP: { bool pressed = (message == WM_KEYDOWN) ? true : false; switch (wParam) { case VK_PAUSE: break; case VK_TAB: break; case VK_RETURN: altEngine.keypress("enter", pressed); break; case VK_SHIFT: altEngine.keypress("shift", pressed); break; case VK_CONTROL: altEngine.keypress("control", pressed); break; case VK_ESCAPE: altEngine.keypress("escape", pressed); break; case VK_UP: altEngine.keypress("up", pressed); break; case VK_LEFT: altEngine.keypress("left", pressed); break; case VK_DOWN: altEngine.keypress("down", pressed); break; case VK_RIGHT: altEngine.keypress("right", pressed); break; } return 0; } case WM_CHAR: altEngine.keystroke((char)wParam); return 0; case WM_SIZE: { int width, height; width = LOWORD(lParam); height = HIWORD(lParam); center.x = width / 2; center.y = height / 2; altEngine.resize(width, height); } return 0; case WM_SYSCOMMAND: switch(wParam) { case SC_SCREENSAVE: case SC_MONITORPOWER: return 0; } break; case WM_DESTROY: #ifndef DIRECTX if (hglrc) { wglMakeCurrent(NULL, NULL); wglDeleteContext(hglrc); ReleaseDC(hwnd, hdc); } #endif altEngine.destroy(); WSACleanup(); PostQuitMessage(0); return 0; } return DefWindowProc(hwnd, message, wParam, lParam); }
void GlContext::create(uint32_t /*_width*/, uint32_t /*_height*/) { m_opengl32dll = bx::dlopen("opengl32.dll"); BGFX_FATAL(NULL != m_opengl32dll, Fatal::UnableToInitialize, "Failed to load opengl32.dll."); wglGetProcAddress = (PFNWGLGETPROCADDRESSPROC)bx::dlsym(m_opengl32dll, "wglGetProcAddress"); BGFX_FATAL(NULL != wglGetProcAddress, Fatal::UnableToInitialize, "Failed get wglGetProcAddress."); // If g_bgfxHwnd is NULL, the assumption is that GL context was created // by user (for example, using SDL, GLFW, etc.) BX_WARN(NULL != g_bgfxHwnd , "bgfx::winSetHwnd with valid window is not called. This might " "be intentional when GL context is created by the user." ); if (NULL != g_bgfxHwnd) { wglMakeCurrent = (PFNWGLMAKECURRENTPROC)bx::dlsym(m_opengl32dll, "wglMakeCurrent"); BGFX_FATAL(NULL != wglMakeCurrent, Fatal::UnableToInitialize, "Failed get wglMakeCurrent."); wglCreateContext = (PFNWGLCREATECONTEXTPROC)bx::dlsym(m_opengl32dll, "wglCreateContext"); BGFX_FATAL(NULL != wglCreateContext, Fatal::UnableToInitialize, "Failed get wglCreateContext."); wglDeleteContext = (PFNWGLDELETECONTEXTPROC)bx::dlsym(m_opengl32dll, "wglDeleteContext"); BGFX_FATAL(NULL != wglDeleteContext, Fatal::UnableToInitialize, "Failed get wglDeleteContext."); m_hdc = GetDC(g_bgfxHwnd); BGFX_FATAL(NULL != m_hdc, Fatal::UnableToInitialize, "GetDC failed!"); // Dummy window to peek into WGL functionality. // // An application can only set the pixel format of a window one time. // Once a window's pixel format is set, it cannot be changed. // MSDN: http://msdn.microsoft.com/en-us/library/windows/desktop/dd369049%28v=vs.85%29.aspx HWND hwnd = CreateWindowA("STATIC" , "" , WS_POPUP|WS_DISABLED , -32000 , -32000 , 0 , 0 , NULL , NULL , GetModuleHandle(NULL) , 0 ); HDC hdc = GetDC(hwnd); BGFX_FATAL(NULL != hdc, Fatal::UnableToInitialize, "GetDC failed!"); HGLRC context = createContext(hdc); wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB"); wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB"); wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddress("wglCreateContextAttribsARB"); wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT"); if (NULL != wglGetExtensionsStringARB) { const char* extensions = (const char*)wglGetExtensionsStringARB(hdc); BX_TRACE("WGL extensions:"); dumpExtensions(extensions); } if (NULL != wglChoosePixelFormatARB && NULL != wglCreateContextAttribsARB) { int32_t attrs[] = { WGL_SAMPLE_BUFFERS_ARB, 0, WGL_SAMPLES_ARB, 0, WGL_SUPPORT_OPENGL_ARB, true, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, WGL_DRAW_TO_WINDOW_ARB, true, WGL_DOUBLE_BUFFER_ARB, true, WGL_COLOR_BITS_ARB, 32, WGL_DEPTH_BITS_ARB, 24, WGL_STENCIL_BITS_ARB, 8, 0 }; int result; uint32_t numFormats = 0; do { result = wglChoosePixelFormatARB(m_hdc, attrs, NULL, 1, &m_pixelFormat, &numFormats); if (0 == result || 0 == numFormats) { attrs[3] >>= 1; attrs[1] = attrs[3] == 0 ? 0 : 1; } } while (0 == numFormats); DescribePixelFormat(m_hdc, m_pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &m_pfd); BX_TRACE("Pixel format:\n" "\tiPixelType %d\n" "\tcColorBits %d\n" "\tcAlphaBits %d\n" "\tcDepthBits %d\n" "\tcStencilBits %d\n" , m_pfd.iPixelType , m_pfd.cColorBits , m_pfd.cAlphaBits , m_pfd.cDepthBits , m_pfd.cStencilBits ); result = SetPixelFormat(m_hdc, m_pixelFormat, &m_pfd); // When window is created by SDL and SDL_WINDOW_OPENGL is set SetPixelFormat // will fail. Just warn and continue. In case it failed for some other reason // create context will fail and it will error out there. BX_WARN(result, "SetPixelFormat failed (last err: 0x%08x)!", GetLastError() ); uint32_t flags = BGFX_CONFIG_DEBUG ? WGL_CONTEXT_DEBUG_BIT_ARB : 0; BX_UNUSED(flags); int32_t contextAttrs[9] = { #if BGFX_CONFIG_RENDERER_OPENGL >= 31 WGL_CONTEXT_MAJOR_VERSION_ARB, BGFX_CONFIG_RENDERER_OPENGL / 10, WGL_CONTEXT_MINOR_VERSION_ARB, BGFX_CONFIG_RENDERER_OPENGL % 10, WGL_CONTEXT_FLAGS_ARB, flags, WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB, #else WGL_CONTEXT_MAJOR_VERSION_ARB, 2, WGL_CONTEXT_MINOR_VERSION_ARB, 1, 0, 0, 0, 0, #endif // BGFX_CONFIG_RENDERER_OPENGL >= 31 0 }; m_context = wglCreateContextAttribsARB(m_hdc, 0, contextAttrs); if (NULL == m_context) { // nVidia doesn't like context profile mask for contexts below 3.2? contextAttrs[6] = WGL_CONTEXT_PROFILE_MASK_ARB == contextAttrs[6] ? 0 : contextAttrs[6]; m_context = wglCreateContextAttribsARB(m_hdc, 0, contextAttrs); } BGFX_FATAL(NULL != m_context, Fatal::UnableToInitialize, "Failed to create context 0x%08x.", GetLastError() ); BX_STATIC_ASSERT(sizeof(contextAttrs) == sizeof(m_contextAttrs) ); memcpy(m_contextAttrs, contextAttrs, sizeof(contextAttrs) ); }
void RenderTexture::Init(int width, int height, bool fboMode) { GLenum err; canvas_hDC = wglGetCurrentDC(); canvas_hRC = wglGetCurrentContext(); m_texID = 0; m_FBO = fboMode; if (width == 0 || height == 0) { int screenSize[4]; glGetIntegerv(GL_VIEWPORT, screenSize); nWidth = screenSize[2]; nHeight = screenSize[3]; } else { nWidth = width; nHeight = height; } // Find the (easiest) format to use if (video.supportNPOT && video.supportTexRects && GL_TEXTURE_RECTANGLE_ARB) { m_texFormat = GL_TEXTURE_RECTANGLE_ARB; } else { // If non-power-of-two textures aren't supported, force them to be power-of-two of the max texture size. m_texFormat = GL_TEXTURE_2D; GLint texSize; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &texSize); bool end=false; int curMax=0; // Make sure its square and a power-of-two for (size_t i=5; !end; i++) { int iSize = powf(2,(float)i); if (iSize < texSize) curMax = iSize; else end = true; } // Divide by 2 to make sure they're no where near their max texture size nWidth = nHeight = (curMax/2); } // Hmm... why was this here? //m_texFormat = GL_TEXTURE_2D; if (m_FBO) { // Frame Buffer OBject mode (newer, better, only supported by newer cards and drivers though) // Reported crash in this section of the code by a user // add exception handling to try and capture it for future versions. try { LOG_INFO << "GFX Info: Initialising FrameBufferObject."; // Generate our buffers and texture glGenFramebuffers(1, &m_frameBuffer ); glGenRenderbuffers(1, &m_depthRenderBuffer ); glGenTextures(1, &m_texID); // -- // Bind frame buffer and texture glBindFramebuffer(GL_FRAMEBUFFER_EXT, m_frameBuffer); glBindTexture(m_texFormat, m_texID); // This is our dynamic texture, which will be loaded with new pixel data // after we're finshed rendering to the p-buffer. glTexImage2D(m_texFormat, 0, GL_RGBA8, nWidth, nHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexParameteri(m_texFormat, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameteri(m_texFormat, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); // And attach it to the FBO so we can render to it glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, m_texFormat, m_texID, 0); // attach a depth buffer to the Frame buffer glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthRenderBuffer ); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, nWidth, nHeight); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthRenderBuffer); CHECK_FRAMEBUFFER_STATUS(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // Unbind the FBO for now } catch (...) { LOG_ERROR << "FrameBuffer Error:" << __FILE__ << ": line #" << __LINE__ << ":" << __FUNCTION__; } } else { // Pixel Buffer Mode LOG_INFO << "Attempting to create a PixelBuffer."; //------------------------------------------------------------------------- // Create a p-buffer for off-screen rendering. //------------------------------------------------------------------------- // Define the minimum pixel format requirements we will need for our // p-buffer. A p-buffer is just like a frame buffer, it can have a depth // buffer associated with it and it can be double buffered. int pf_attr[] = { WGL_SUPPORT_OPENGL_ARB, TRUE, // P-buffer will be used with OpenGL WGL_DRAW_TO_PBUFFER_ARB, TRUE, // Enable render to p-buffer WGL_BIND_TO_TEXTURE_RGBA_ARB, TRUE, // P-buffer will be used as a texture WGL_RED_BITS_ARB, 8, // At least 8 bits for RED channel WGL_GREEN_BITS_ARB, 8, // At least 8 bits for GREEN channel WGL_BLUE_BITS_ARB, 8, // At least 8 bits for BLUE channel WGL_ALPHA_BITS_ARB, 8, // At least 8 bits for ALPHA channel WGL_DEPTH_BITS_ARB, 16, // At least 16 bits for depth buffer WGL_DOUBLE_BUFFER_ARB, FALSE, // We don't require double buffering 0 // Zero terminates the list }; unsigned int iCount = 0; int iPixelFormat = 0; // g_hdc = wxglcanvas hdc wglChoosePixelFormatARB(canvas_hDC, (const int*)pf_attr, NULL, 1, &iPixelFormat, &iCount); if (iCount == 0) { LOG_ERROR << "wglChoosePixelFormatARB() Failed! PixelBuffer could not find an acceptable pixel format!" << glGetError(); return; } // Set some p-buffer attributes so that we can use this p-buffer as a // 2D RGBA texture target. int pb_attr[] = { WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB, // Our p-buffer will have a texture format of RGBA WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, // Of texture target will be GL_TEXTURE_2D 0 // Zero terminates the list }; // Create the p-buffer... m_hPBuffer = wglCreatePbufferARB(canvas_hDC, iPixelFormat, nWidth, nHeight, pb_attr ); // Error check err = glGetError(); if (!m_hPBuffer) { LOG_ERROR << "Could not create the PixelBuffer." << err; return; } else if (err==GL_NO_ERROR) { LOG_INFO << "Successfully created the PixelBuffer."; } else if (err==GL_INVALID_ENUM) { LOG_ERROR << "Invalid Enum during PixelBuffer creation."; } else if (err==GL_INVALID_VALUE) { LOG_ERROR << "Invalid Value during PixelBuffer creation."; } else if (err==GL_INVALID_OPERATION) { LOG_ERROR << "Invalid Operation during PixelBuffer creation."; } else if (err==GL_OUT_OF_MEMORY) { LOG_ERROR << "Critical error! Out-of-Memory during PixelBuffer creation. PixelBuffer could not be created."; return; } else { LOG_ERROR << "PixelBuffer created, but an unknown error occured :" << err; } m_hDC = wglGetPbufferDCARB( m_hPBuffer ); m_hRC = wglCreateContext( m_hDC ); int h=0, w=0; wglQueryPbufferARB( m_hPBuffer, WGL_PBUFFER_HEIGHT_ARB, &h ); wglQueryPbufferARB( m_hPBuffer, WGL_PBUFFER_WIDTH_ARB, &w ); if (h!=nHeight || w!=nWidth) { LOG_ERROR << "The width and height of the created PixelBuffer don't match the requirements. Image likely to come out distorted."; nHeight = h; nWidth = w; } if (!wglShareLists(canvas_hRC, m_hRC)) { err = glGetError(); LOG_ERROR << "Call to wglShareLists() failed for our PixelBuffer."; } // We were successful in creating a p-buffer. We can now make its context // current and set it up just like we would a regular context // attached to a window. if (!wglMakeCurrent(m_hDC, m_hRC)) { err = glGetError(); LOG_ERROR << "wglMakeCurrent() Failed! Could not make the PBuffer's context current!" << err; } // Setup OpenGL RenderState InitGL(); // This is our dynamic texture, which will be loaded with new pixel data // after we're finshed rendering to the p-buffer. glGenTextures(1, &m_texID); glBindTexture(m_texFormat, m_texID); glTexImage2D(m_texFormat, 0, GL_RGBA8, nWidth, nHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL ); //GL_FLOAT glTexParameteri(m_texFormat, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameteri(m_texFormat, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); //glTexParameteri(texFormat, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); //glTexParameteri(texFormat, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); // Now set the current context back to original. if (!wglMakeCurrent(canvas_hDC, canvas_hRC)) { err = glGetError(); LOG_ERROR << "wglMakeCurrent() Failed! Could not return the context back to the wxGLCanvas!" << err; } } }
void VisualInfoARB (GLContext* ctx) { int attrib[32], value[32], n_attrib, n_pbuffer=0, n_float=0; int i, pf, maxpf; unsigned int c; /* to get pbuffer capable pixel formats */ attrib[0] = WGL_DRAW_TO_PBUFFER_ARB; attrib[1] = GL_TRUE; attrib[2] = 0; wglChoosePixelFormatARB(ctx->dc, attrib, 0, 1, &pf, &c); /* query number of pixel formats */ attrib[0] = WGL_NUMBER_PIXEL_FORMATS_ARB; wglGetPixelFormatAttribivARB(ctx->dc, 0, 0, 1, attrib, value); maxpf = value[0]; for (i=0; i<32; i++) value[i] = 0; attrib[0] = WGL_SUPPORT_OPENGL_ARB; attrib[1] = WGL_DRAW_TO_WINDOW_ARB; attrib[2] = WGL_DRAW_TO_BITMAP_ARB; attrib[3] = WGL_ACCELERATION_ARB; /* WGL_NO_ACCELERATION_ARB, WGL_GENERIC_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB */ attrib[4] = WGL_SWAP_METHOD_ARB; /* WGL_SWAP_EXCHANGE_ARB, WGL_SWAP_COPY_ARB, WGL_SWAP_UNDEFINED_ARB */ attrib[5] = WGL_DOUBLE_BUFFER_ARB; attrib[6] = WGL_STEREO_ARB; attrib[7] = WGL_PIXEL_TYPE_ARB; /* WGL_TYPE_RGBA_ARB, WGL_TYPE_COLORINDEX_ARB, WGL_TYPE_RGBA_FLOAT_ATI (WGL_ATI_pixel_format_float) */ /* Color buffer information */ attrib[8] = WGL_COLOR_BITS_ARB; attrib[9] = WGL_RED_BITS_ARB; attrib[10] = WGL_GREEN_BITS_ARB; attrib[11] = WGL_BLUE_BITS_ARB; attrib[12] = WGL_ALPHA_BITS_ARB; /* Accumulation buffer information */ attrib[13] = WGL_ACCUM_BITS_ARB; attrib[14] = WGL_ACCUM_RED_BITS_ARB; attrib[15] = WGL_ACCUM_GREEN_BITS_ARB; attrib[16] = WGL_ACCUM_BLUE_BITS_ARB; attrib[17] = WGL_ACCUM_ALPHA_BITS_ARB; /* Depth, stencil, and aux buffer information */ attrib[18] = WGL_DEPTH_BITS_ARB; attrib[19] = WGL_STENCIL_BITS_ARB; attrib[20] = WGL_AUX_BUFFERS_ARB; /* Layer information */ attrib[21] = WGL_NUMBER_OVERLAYS_ARB; attrib[22] = WGL_NUMBER_UNDERLAYS_ARB; attrib[23] = WGL_SWAP_LAYER_BUFFERS_ARB; attrib[24] = WGL_SAMPLES_ARB; attrib[25] = WGL_SUPPORT_GDI_ARB; n_attrib = 26; if (WGLEW_ARB_pbuffer) { attrib[n_attrib] = WGL_DRAW_TO_PBUFFER_ARB; n_pbuffer = n_attrib; n_attrib++; } if (WGLEW_NV_float_buffer) { attrib[n_attrib] = WGL_FLOAT_COMPONENTS_NV; n_float = n_attrib; n_attrib++; } if (!verbose) { /* print table header */ fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n"); fprintf(file, " | | visual | color | ax dp st | accum | layer |\n"); fprintf(file, " | id | tp ac gd fm db sw st ms | sz r g b a | bf th cl | sz r g b a | ov un sw |\n"); fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n"); /* loop through all the pixel formats */ for(i = 1; i <= maxpf; i++) { wglGetPixelFormatAttribivARB(ctx->dc, i, 0, n_attrib, attrib, value); /* only describe this format if it supports OpenGL */ if (!value[0]) continue; /* by default show only fully accelerated window or pbuffer capable visuals */ if (!showall && ((value[2] && !value[1]) || (!WGLEW_ARB_pbuffer || !value[n_pbuffer]) || (value[3] != WGL_FULL_ACCELERATION_ARB))) continue; /* print out the information for this visual */ /* visual id */ fprintf(file, " |% 4d | ", i); /* visual type */ if (value[1]) { if (WGLEW_ARB_pbuffer && value[n_pbuffer]) fprintf(file, "wp "); else fprintf(file, "wn "); } else { if (value[2]) fprintf(file, "bm "); else if (WGLEW_ARB_pbuffer && value[n_pbuffer]) fprintf(file, "pb "); } /* acceleration */ fprintf(file, "%s ", value[3] == WGL_FULL_ACCELERATION_ARB ? "fu" : value[3] == WGL_GENERIC_ACCELERATION_ARB ? "ge" : value[3] == WGL_NO_ACCELERATION_ARB ? "no" : ". "); /* gdi support */ fprintf(file, " %c ", value[25] ? 'y' : '.'); /* format */ if (WGLEW_NV_float_buffer && value[n_float]) fprintf(file, " f "); else if (WGLEW_ATI_pixel_format_float && value[7] == WGL_TYPE_RGBA_FLOAT_ATI) fprintf(file, " f "); else if (value[7] == WGL_TYPE_RGBA_ARB) fprintf(file, " i "); else if (value[7] == WGL_TYPE_COLORINDEX_ARB) fprintf(file, " c "); /* double buffer */ fprintf(file, " %c ", value[5] ? 'y' : '.'); /* swap method */ if (value[4] == WGL_SWAP_EXCHANGE_ARB) fprintf(file, " x "); else if (value[4] == WGL_SWAP_COPY_ARB) fprintf(file, " c "); else if (value[4] == WGL_SWAP_UNDEFINED_ARB) fprintf(file, " . "); else fprintf(file, " . "); /* stereo */ fprintf(file, " %c ", value[6] ? 'y' : '.'); /* multisample */ if (value[24] > 0) fprintf(file, "%2d | ", value[24]); else fprintf(file, " . | "); /* color size */ if (value[8]) fprintf(file, "%3d ", value[8]); else fprintf(file, " . "); /* red */ if (value[9]) fprintf(file, "%2d ", value[9]); else fprintf(file, " . "); /* green */ if (value[10]) fprintf(file, "%2d ", value[10]); else fprintf(file, " . "); /* blue */ if (value[11]) fprintf(file, "%2d ", value[11]); else fprintf(file, " . "); /* alpha */ if (value[12]) fprintf(file, "%2d | ", value[12]); else fprintf(file, " . | "); /* aux buffers */ if (value[20]) fprintf(file, "%2d ", value[20]); else fprintf(file, " . "); /* depth */ if (value[18]) fprintf(file, "%2d ", value[18]); else fprintf(file, " . "); /* stencil */ if (value[19]) fprintf(file, "%2d | ", value[19]); else fprintf(file, " . | "); /* accum size */ if (value[13]) fprintf(file, "%3d ", value[13]); else fprintf(file, " . "); /* accum red */ if (value[14]) fprintf(file, "%2d ", value[14]); else fprintf(file, " . "); /* accum green */ if (value[15]) fprintf(file, "%2d ", value[15]); else fprintf(file, " . "); /* accum blue */ if (value[16]) fprintf(file, "%2d ", value[16]); else fprintf(file, " . "); /* accum alpha */ if (value[17]) fprintf(file, "%2d | ", value[17]); else fprintf(file, " . | "); /* overlay */ if (value[21]) fprintf(file, "%2d ", value[21]); else fprintf(file, " . "); /* underlay */ if (value[22]) fprintf(file, "%2d ", value[22]); else fprintf(file, " . "); /* layer swap */ if (value[23]) fprintf(file, "y "); else fprintf(file, " . "); fprintf(file, "|\n"); } /* print table footer */ fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n"); fprintf(file, " | | visual | color | ax dp st | accum | layer |\n"); fprintf(file, " | id | tp ac gd fm db sw st ms | sz r g b a | bf th cl | sz r g b a | ov un sw |\n"); fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n"); } else /* verbose */ { #if 0 fprintf(file, "\n"); /* loop through all the pixel formats */ for(i = 1; i <= maxpf; i++) { DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd); /* only describe this format if it supports OpenGL */ if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL) || (drawableonly && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))) continue; fprintf(file, "Visual ID: %2d depth=%d class=%s\n", i, pfd.cDepthBits, pfd.cColorBits <= 8 ? "PseudoColor" : "TrueColor"); fprintf(file, " bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n", pfd.cColorBits, pfd.bReserved, pfd.iPixelType == PFD_TYPE_RGBA ? "rgba" : "ci", pfd.dwFlags & PFD_DOUBLEBUFFER, pfd.dwFlags & PFD_STEREO); fprintf(file, " generic=%d generic accelerated=%d\n", (pfd.dwFlags & PFD_GENERIC_FORMAT) == PFD_GENERIC_FORMAT, (pfd.dwFlags & PFD_GENERIC_ACCELERATED) == PFD_GENERIC_ACCELERATED); fprintf(file, " rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cRedBits, pfd.cGreenBits, pfd.cBlueBits, pfd.cAlphaBits); fprintf(file, " auxBuffers=%d depthSize=%d stencilSize=%d\n", pfd.cAuxBuffers, pfd.cDepthBits, pfd.cStencilBits); fprintf(file, " accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cAccumRedBits, pfd.cAccumGreenBits, pfd.cAccumBlueBits, pfd.cAccumAlphaBits); fprintf(file, " multiSample=%d multisampleBuffers=%d\n", 0, 0); fprintf(file, " Opaque.\n"); } #endif } }