void GraphicsWindowQt::qglFormat2traits( const QGLFormat& format, osg::GraphicsContext::Traits* traits ) { traits->red = format.redBufferSize(); traits->green = format.greenBufferSize(); traits->blue = format.blueBufferSize(); traits->alpha = format.alpha() ? format.alphaBufferSize() : 0; traits->depth = format.depth() ? format.depthBufferSize() : 0; traits->stencil = format.stencil() ? format.stencilBufferSize() : 0; traits->sampleBuffers = format.sampleBuffers() ? 1 : 0; traits->samples = format.samples(); traits->quadBufferStereo = format.stereo(); traits->doubleBuffer = format.doubleBuffer(); traits->vsync = format.swapInterval() >= 1; }
string glinfo:: pretty_format(const QGLFormat& f) { QGLFormat::OpenGLVersionFlags flag = f.openGLVersionFlags(); stringstream s; s << "accum=" << f.accum() << endl << "accumBufferSize=" << f.accumBufferSize() << endl << "alpha=" << f.alpha() << endl << "alphaBufferSize=" << f.alphaBufferSize() << endl << "blueBufferSize=" << f.blueBufferSize() << endl << "depth=" << f.depth() << endl << "depthBufferSize=" << f.depthBufferSize() << endl << "directRendering=" << f.directRendering() << endl << "doubleBuffer=" << f.doubleBuffer() << endl << "greenBufferSize=" << f.greenBufferSize() << endl << "hasOverlay=" << f.hasOverlay() << endl << "redBufferSize=" << f.redBufferSize() << endl << "rgba=" << f.rgba() << endl << "sampleBuffers=" << f.sampleBuffers() << endl << "samples=" << f.samples() << endl << "stencil=" << f.stencil() << endl << "stencilBufferSize=" << f.stencilBufferSize() << endl << "stereo=" << f.stereo() << endl << "swapInterval=" << f.swapInterval() << endl << "" << endl << "hasOpenGL=" << f.hasOpenGL() << endl << "hasOpenGLOverlays=" << f.hasOpenGLOverlays() << endl << "OpenGL_Version_None=" << (QGLFormat::OpenGL_Version_None == flag) << endl << "OpenGL_Version_1_1=" << (QGLFormat::OpenGL_Version_1_1 & flag) << endl << "OpenGL_Version_1_2=" << (QGLFormat::OpenGL_Version_1_2 & flag) << endl << "OpenGL_Version_1_3=" << (QGLFormat::OpenGL_Version_1_3 & flag) << endl << "OpenGL_Version_1_4=" << (QGLFormat::OpenGL_Version_1_4 & flag) << endl << "OpenGL_Version_1_5=" << (QGLFormat::OpenGL_Version_1_5 & flag) << endl << "OpenGL_Version_2_0=" << (QGLFormat::OpenGL_Version_2_0 & flag) << endl << "OpenGL_Version_2_1=" << (QGLFormat::OpenGL_Version_2_1 & flag) << endl << "OpenGL_Version_3_0=" << (QGLFormat::OpenGL_Version_3_0 & flag) << endl << "OpenGL_ES_CommonLite_Version_1_0=" << (QGLFormat::OpenGL_ES_CommonLite_Version_1_0 & flag) << endl << "OpenGL_ES_Common_Version_1_0=" << (QGLFormat::OpenGL_ES_Common_Version_1_0 & flag) << endl << "OpenGL_ES_CommonLite_Version_1_1=" << (QGLFormat::OpenGL_ES_CommonLite_Version_1_1 & flag) << endl << "OpenGL_ES_Common_Version_1_1=" << (QGLFormat::OpenGL_ES_Common_Version_1_1 & flag) << endl << "OpenGL_ES_Version_2_0=" << (QGLFormat::OpenGL_ES_Version_2_0 & flag) << endl; return s.str(); }
// static void SharedGLContext::setWidget(const QGLWidget* pWidget) { s_pSharedGLWidget = pWidget; qDebug() << "Set root GL Context widget valid:" << pWidget << (pWidget && pWidget->isValid()); const QGLContext* pContext = pWidget->context(); qDebug() << "Created root GL Context valid:" << pContext << (pContext && pContext->isValid()); if (pWidget) { QGLFormat format = pWidget->format(); qDebug() << "Root GL Context format:"; qDebug() << "Double Buffering:" << format.doubleBuffer(); qDebug() << "Swap interval:" << format.swapInterval(); qDebug() << "Depth buffer:" << format.depth(); qDebug() << "Direct rendering:" << format.directRendering(); qDebug() << "Has overlay:" << format.hasOverlay(); qDebug() << "RGBA:" << format.rgba(); qDebug() << "Sample buffers:" << format.sampleBuffers(); qDebug() << "Samples:" << format.samples(); qDebug() << "Stencil buffers:" << format.stencil(); qDebug() << "Stereo:" << format.stereo(); } }
void qt_eglproperties_set_glformat(QEglProperties& eglProperties, const QGLFormat& glFormat) { int redSize = glFormat.redBufferSize(); int greenSize = glFormat.greenBufferSize(); int blueSize = glFormat.blueBufferSize(); int alphaSize = glFormat.alphaBufferSize(); int depthSize = glFormat.depthBufferSize(); int stencilSize = glFormat.stencilBufferSize(); int sampleCount = glFormat.samples(); bool prefer32Bit = false; #ifdef Q_OS_SYMBIAN // on Symbian we prefer 32-bit configs, unless we're using the low memory GPU prefer32Bit = !QSymbianGraphicsSystemEx::hasBCM2727(); #endif if (prefer32Bit) { if (glFormat.alpha() && alphaSize <= 0) alphaSize = 8; if (glFormat.depth() && depthSize <= 0) depthSize = 24; if (glFormat.stencil() && stencilSize <= 0) stencilSize = 8; if (glFormat.sampleBuffers() && sampleCount <= 0) sampleCount = 1; redSize = redSize > 0 ? redSize : 8; greenSize = greenSize > 0 ? greenSize : 8; blueSize = blueSize > 0 ? blueSize : 8; alphaSize = alphaSize > 0 ? alphaSize : 8; depthSize = depthSize > 0 ? depthSize : 24; stencilSize = stencilSize > 0 ? stencilSize : 8; sampleCount = sampleCount >= 0 ? sampleCount : 4; } else { // QGLFormat uses a magic value of -1 to indicate "don't care", even when a buffer of that // type has been requested. So we must check QGLFormat's booleans too if size is -1: if (glFormat.alpha() && alphaSize <= 0) alphaSize = 1; if (glFormat.depth() && depthSize <= 0) depthSize = 1; if (glFormat.stencil() && stencilSize <= 0) stencilSize = 1; if (glFormat.sampleBuffers() && sampleCount <= 0) sampleCount = 1; // We want to make sure 16-bit configs are chosen over 32-bit configs as they will provide // the best performance. The EGL config selection algorithm is a bit stange in this regard: // The selection criteria for EGL_BUFFER_SIZE is "AtLeast", so we can't use it to discard // 32-bit configs completely from the selection. So it then comes to the sorting algorithm. // The red/green/blue sizes have a sort priority of 3, so they are sorted by first. The sort // order is special and described as "by larger _total_ number of color bits.". So EGL will // put 32-bit configs in the list before the 16-bit configs. However, the spec also goes on // to say "If the requested number of bits in attrib_list for a particular component is 0, // then the number of bits for that component is not considered". This part of the spec also // seems to imply that setting the red/green/blue bits to zero means none of the components // are considered and EGL disregards the entire sorting rule. It then looks to the next // highest priority rule, which is EGL_BUFFER_SIZE. Despite the selection criteria being // "AtLeast" for EGL_BUFFER_SIZE, it's sort order is "smaller" meaning 16-bit configs are // put in the list before 32-bit configs. So, to make sure 16-bit is preffered over 32-bit, // we must set the red/green/blue sizes to zero. This has an unfortunate consequence that // if the application sets the red/green/blue size to 5/6/5 on the QGLFormat, they will // probably get a 32-bit config, even when there's an RGB565 config available. Oh well. // Now normalize the values so -1 becomes 0 redSize = redSize > 0 ? redSize : 0; greenSize = greenSize > 0 ? greenSize : 0; blueSize = blueSize > 0 ? blueSize : 0; alphaSize = alphaSize > 0 ? alphaSize : 0; depthSize = depthSize > 0 ? depthSize : 0; stencilSize = stencilSize > 0 ? stencilSize : 0; sampleCount = sampleCount > 0 ? sampleCount : 0; } eglProperties.setValue(EGL_RED_SIZE, redSize); eglProperties.setValue(EGL_GREEN_SIZE, greenSize); eglProperties.setValue(EGL_BLUE_SIZE, blueSize); eglProperties.setValue(EGL_ALPHA_SIZE, alphaSize); eglProperties.setValue(EGL_DEPTH_SIZE, depthSize); eglProperties.setValue(EGL_STENCIL_SIZE, stencilSize); eglProperties.setValue(EGL_SAMPLES, sampleCount); eglProperties.setValue(EGL_SAMPLE_BUFFERS, sampleCount ? 1 : 0); }
static void qt_format_to_attrib_list(bool has_render_texture, const QGLFormat &f, int attribs[]) { int i = 0; attribs[i++] = WGL_SUPPORT_OPENGL_ARB; attribs[i++] = TRUE; attribs[i++] = WGL_DRAW_TO_PBUFFER_ARB; attribs[i++] = TRUE; if (has_render_texture) { attribs[i++] = WGL_BIND_TO_TEXTURE_RGBA_ARB; attribs[i++] = TRUE; } attribs[i++] = WGL_COLOR_BITS_ARB; attribs[i++] = 32; attribs[i++] = WGL_DOUBLE_BUFFER_ARB; attribs[i++] = FALSE; if (f.stereo()) { attribs[i++] = WGL_STEREO_ARB; attribs[i++] = TRUE; } if (f.depth()) { attribs[i++] = WGL_DEPTH_BITS_ARB; attribs[i++] = f.depthBufferSize() == -1 ? 24 : f.depthBufferSize(); } if (f.redBufferSize() != -1) { attribs[i++] = WGL_RED_BITS_ARB; attribs[i++] = f.redBufferSize(); } if (f.greenBufferSize() != -1) { attribs[i++] = WGL_GREEN_BITS_ARB; attribs[i++] = f.greenBufferSize(); } if (f.blueBufferSize() != -1) { attribs[i++] = WGL_BLUE_BITS_ARB; attribs[i++] = f.blueBufferSize(); } if (f.alpha()) { attribs[i++] = WGL_ALPHA_BITS_ARB; attribs[i++] = f.alphaBufferSize() == -1 ? 8 : f.alphaBufferSize(); } if (f.accum()) { attribs[i++] = WGL_ACCUM_BITS_ARB; attribs[i++] = f.accumBufferSize() == -1 ? 16 : f.accumBufferSize(); } if (f.stencil()) { attribs[i++] = WGL_STENCIL_BITS_ARB; attribs[i++] = f.stencilBufferSize() == -1 ? 8 : f.stencilBufferSize(); } if ((f.redBufferSize() > 8 || f.greenBufferSize() > 8 || f.blueBufferSize() > 8 || f.alphaBufferSize() > 8) && (QGLExtensions::glExtensions() & QGLExtensions::NVFloatBuffer)) { attribs[i++] = WGL_FLOAT_COMPONENTS_NV; attribs[i++] = TRUE; } if (f.sampleBuffers()) { attribs[i++] = WGL_SAMPLE_BUFFERS_ARB; attribs[i++] = 1; attribs[i++] = WGL_SAMPLES_ARB; attribs[i++] = f.samples() == -1 ? 16 : f.samples(); } attribs[i] = 0; }
AGLPixelFormat QGLContextPrivate::tryFormat(const QGLFormat &format) { GLint attribs[40], cnt = 0; bool device_is_pixmap = (paintDevice->devType() == QInternal::Pixmap); attribs[cnt++] = AGL_RGBA; attribs[cnt++] = AGL_BUFFER_SIZE; attribs[cnt++] = device_is_pixmap ? static_cast<QPixmap *>(paintDevice)->depth() : 32; attribs[cnt++] = AGL_LEVEL; attribs[cnt++] = format.plane(); if (format.redBufferSize() != -1) { attribs[cnt++] = AGL_RED_SIZE; attribs[cnt++] = format.redBufferSize(); } if (format.greenBufferSize() != -1) { attribs[cnt++] = AGL_GREEN_SIZE; attribs[cnt++] = format.greenBufferSize(); } if (format.blueBufferSize() != -1) { attribs[cnt++] = AGL_BLUE_SIZE; attribs[cnt++] = format.blueBufferSize(); } if (device_is_pixmap) { attribs[cnt++] = AGL_PIXEL_SIZE; attribs[cnt++] = static_cast<QPixmap *>(paintDevice)->depth(); attribs[cnt++] = AGL_OFFSCREEN; if(!format.alpha()) { attribs[cnt++] = AGL_ALPHA_SIZE; attribs[cnt++] = 8; } } else { if(format.doubleBuffer()) attribs[cnt++] = AGL_DOUBLEBUFFER; } if(glFormat.stereo()) attribs[cnt++] = AGL_STEREO; if(format.alpha()) { attribs[cnt++] = AGL_ALPHA_SIZE; attribs[cnt++] = format.alphaBufferSize() == -1 ? 8 : format.alphaBufferSize(); } if(format.stencil()) { attribs[cnt++] = AGL_STENCIL_SIZE; attribs[cnt++] = format.stencilBufferSize() == -1 ? 8 : format.stencilBufferSize(); } if(format.depth()) { attribs[cnt++] = AGL_DEPTH_SIZE; attribs[cnt++] = format.depthBufferSize() == -1 ? 32 : format.depthBufferSize(); } if(format.accum()) { attribs[cnt++] = AGL_ACCUM_RED_SIZE; attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize(); attribs[cnt++] = AGL_ACCUM_BLUE_SIZE; attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize(); attribs[cnt++] = AGL_ACCUM_GREEN_SIZE; attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize(); attribs[cnt++] = AGL_ACCUM_ALPHA_SIZE; attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize(); } if(format.sampleBuffers()) { attribs[cnt++] = AGL_SAMPLE_BUFFERS_ARB; attribs[cnt++] = 1; attribs[cnt++] = AGL_SAMPLES_ARB; attribs[cnt++] = format.samples() == -1 ? 4 : format.samples(); } attribs[cnt] = AGL_NONE; Q_ASSERT(cnt < 40); return aglChoosePixelFormat(0, 0, attribs); }