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(); }
MythRenderOpenGL* MythRenderOpenGL::Create(const QString &painter, QPaintDevice* device) { #ifdef USE_OPENGL_QT5 MythRenderFormat format = QSurfaceFormat::defaultFormat(); format.setDepthBufferSize(0); format.setSwapBehavior(QSurfaceFormat::DoubleBuffer); # ifdef USING_OPENGLES format.setRenderableType(QSurfaceFormat::OpenGLES); # endif #else MythRenderFormat format = QGLFormat(QGL::NoDepthBuffer); #endif bool setswapinterval = false; int synctovblank = -1; #ifdef USING_X11 synctovblank = CheckNVOpenGLSyncToVBlank(); #endif if (synctovblank < 0) { LOG(VB_GENERAL, LOG_WARNING, LOC + "Could not determine whether Sync " "to VBlank is enabled."); } else if (synctovblank == 0) { // currently only Linux NVidia is supported and there is no way of // forcing sync to vblank after the app has started. util-nvctrl will // warn the user and offer advice on settings. } else { LOG(VB_GENERAL, LOG_INFO, LOC + "Sync to VBlank is enabled (good!)"); } #if defined(Q_OS_MAC) LOG(VB_GENERAL, LOG_INFO, LOC + "Forcing swap interval for OS X."); setswapinterval = true; #endif if (setswapinterval) format.setSwapInterval(1); #if ANDROID int openGLVersionFlags = QGLFormat::OpenGL_ES_Version_2_0; LOG(VB_GENERAL, LOG_INFO, "OpenGL ES2 forced for Android"); #elif defined USE_OPENGL_QT5 && defined USING_OPENGLES int openGLVersionFlags = QGLFormat::OpenGL_ES_Version_2_0; #else // Check OpenGL version supported QGLWidget *dummy = new QGLWidget; dummy->makeCurrent(); QGLFormat qglFormat = dummy->format(); int openGLVersionFlags = qglFormat.openGLVersionFlags(); delete dummy; #endif #ifdef USING_OPENGLES if (!(openGLVersionFlags & QGLFormat::OpenGL_ES_Version_2_0)) { LOG(VB_GENERAL, LOG_WARNING, "Using OpenGL ES 2.0 render, however OpenGL ES 2.0 " "version not supported"); } if (device) return new MythRenderOpenGL2ES(format, device); return new MythRenderOpenGL2ES(format); #else if ((openGLVersionFlags & QGLFormat::OpenGL_Version_2_0) && (painter.contains(OPENGL2_PAINTER) || painter.contains(AUTO_PAINTER) || painter.isEmpty())) { LOG(VB_GENERAL, LOG_INFO, "Trying the OpenGL 2.0 render"); format.setVersion(2,0); if (device) return new MythRenderOpenGL2(format, device); return new MythRenderOpenGL2(format); } if (!(openGLVersionFlags & QGLFormat::OpenGL_Version_1_2)) { LOG(VB_GENERAL, LOG_WARNING, "OpenGL 1.2 not supported, get new hardware!"); return NULL; } LOG(VB_GENERAL, LOG_INFO, "Trying the OpenGL 1.2 render"); format.setVersion(1,3); if (device) return new MythRenderOpenGL1(format, device); return new MythRenderOpenGL1(format); #endif }
/* ======================== getDriverInfoString fills the GL info widget with text ======================== */ QString CGLWidget::getDriverInfoString( void ) const { // the context must be valied! if( !context()->isValid() ) return QString( "<invalid OpenGL context>" ); // read OpenGL infos QString text; text += tr( "Vendor: %1\n" ).arg( (const char*)glGetString( GL_VENDOR ) ); text += tr( "Renderer: %1\n" ).arg( (const char*)glGetString( GL_RENDERER ) ); text += tr( "Version: %1\n" ).arg( (const char*)glGetString( GL_VERSION ) ); text += tr( "\n" ); // print framebuffer format QGLFormat fmt = context()->format(); text += tr( "Framebuffer Format:\n" ); text += tr( " RGBA bits: (%1,%2,%3,%4)\n" ). arg( fmt.redBufferSize() ). arg( fmt.greenBufferSize() ). arg( fmt.blueBufferSize() ). arg( fmt.alphaBufferSize() ); text += tr( " Depth bits: %1\n" ).arg( fmt.depthBufferSize() ); text += tr( " Stencil bits: %1\n" ).arg( fmt.stencilBufferSize() ); text += tr( "\n" ); // shading language version if( fmt.openGLVersionFlags() & fmt.OpenGL_Version_2_0 ) { QString version( (const char*)glGetString( GL_SHADING_LANGUAGE_VERSION ) ); text += QString( "Shading Language Version: %1\n" ).arg( version ); } // check for geometry shader bool hasGeoShader = false; #ifdef CONFIG_ENABLE_GEOMETRY_SHADER hasGeoShader = ( NULL != strstr( (const char*)glGetString( GL_EXTENSIONS ), "GL_EXT_geometry_shader4" ) ); if( hasGeoShader ) { text += tr( "GL_EXT_geometry_shader4 available\n" ); } else { text += tr( "GL_EXT_geometry_shader4 not supported\n" ); } #endif text += tr( "\n" ); GLint i; #define PRINT_CONSTANT(Name) \ glGetIntegerv( Name, &i ); \ text += tr( #Name " = %1\n" ).arg( i ); PRINT_CONSTANT( GL_MAX_TEXTURE_SIZE ); PRINT_CONSTANT( GL_MAX_TEXTURE_UNITS ); PRINT_CONSTANT( GL_MAX_VERTEX_ATTRIBS ); PRINT_CONSTANT( GL_MAX_VERTEX_UNIFORM_COMPONENTS ); PRINT_CONSTANT( GL_MAX_VARYING_FLOATS ); // alias for GL_MAX_VARYING_COMPONENTS_EXT PRINT_CONSTANT( GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS ); PRINT_CONSTANT( GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS ); PRINT_CONSTANT( GL_MAX_TEXTURE_IMAGE_UNITS ); PRINT_CONSTANT( GL_MAX_TEXTURE_COORDS ); PRINT_CONSTANT( GL_MAX_FRAGMENT_UNIFORM_COMPONENTS ); if( hasGeoShader ) { PRINT_CONSTANT( GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT ); PRINT_CONSTANT( GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT ); PRINT_CONSTANT( GL_MAX_VERTEX_VARYING_COMPONENTS_EXT ); PRINT_CONSTANT( GL_MAX_VARYING_COMPONENTS_EXT ); PRINT_CONSTANT( GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT) ; PRINT_CONSTANT( GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT ); PRINT_CONSTANT( GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT ); } #undef PRINT_CONSTANT return text; }
MainWindow::MainWindow(QWidget * parent, FormBar * bar): QMainWindow(parent), m_formbar(bar) { setMenuBar(new QMenuBar(this)); QMenu *fileMenu = menuBar() -> addMenu(tr("&File")); QAction *openAct = new QAction(tr("&Open"), this); openAct->setShortcuts(QKeySequence::Open); openAct->setStatusTip(tr("Open")); connect(openAct, SIGNAL(triggered()), this, SLOT(openFile())); // Quit action QAction *quitAct = new QAction(tr("&Quit"), this); quitAct->setShortcuts(QKeySequence::Quit); quitAct->setStatusTip(tr("Quit")); connect(quitAct, SIGNAL(triggered()), this, SLOT(close())); fileMenu->addAction(openAct); fileMenu->addAction(quitAct); QGLFormat glFormat; std::cout << glFormat.openGLVersionFlags() << std::endl; std::cout << (QGLFormat::OpenGL_Version_3_0 <= glFormat.openGLVersionFlags()) << std::endl; if(QGLFormat::OpenGL_Version_3_3 & glFormat.openGLVersionFlags()) { glFormat.setVersion( 3,3 ); } else { glFormat.setVersion( 2, 1 ); } std::cout << "GL Version: " << glFormat.majorVersion() << " " << glFormat.minorVersion() << std::endl; glFormat.setProfile( QGLFormat::CompatibilityProfile ); glFormat.setSampleBuffers( true ); m_glwidget = new GLWidget(glFormat,this); connect(this,SIGNAL(meshLoaded(std::shared_ptr<const MeshPackage>)), m_glwidget,SLOT(receiveMesh(std::shared_ptr<const MeshPackage>))); connect(this,SIGNAL(formLoaded(const FormPackage &)) , m_glwidget,SLOT(receiveForm(const FormPackage &))); setCentralWidget(m_glwidget); QDockWidget * dock = new QDockWidget(tr("Form Chooser"),this); if(!m_formbar) { m_formbar = new FormBar(this); } dock->setWidget(m_formbar); addDockWidget(Qt::LeftDockWidgetArea, dock); connect(this,SIGNAL(loadingNewMesh()) , m_glwidget,SLOT(unloadMesh())); connect(this,SIGNAL(formLoaded(const FormPackage &)) , m_formbar,SLOT(receiveForm(const FormPackage &))); connect(this,SIGNAL(particlesLoaded(std::shared_ptr<VertexBufferObject>)) , m_glwidget,SLOT(receiveParticles(std::shared_ptr<VertexBufferObject>))); connect( m_formbar, SIGNAL(enableForm(const QString &)), m_glwidget, SLOT(enableForm(const QString &))); connect( m_formbar, SIGNAL(disableForm(const QString &)), m_glwidget, SLOT(disableForm(const QString &))); connect( m_formbar, SIGNAL(clearForms(void)), m_glwidget, SLOT(clearForms(void))); }