void LOpenGLComponent::renderOpenGL() { if(hasCallback("renderOpenGL")) { const float desktopScale = (float) openGLContext.getRenderingScale(); ScopedPointer<LowLevelGraphicsContext> glRenderer( createOpenGLGraphicsContext ( openGLContext, roundToInt (desktopScale * Component::getWidth()), roundToInt (desktopScale * Component::getHeight()) ) ); if(glRenderer != nullptr) { Graphics g(*glRenderer); g.addTransform (AffineTransform::scale (desktopScale)); LGraphics lg(LUA::Get(), g); callback( "renderOpenGL", 1, { new LRefBase("Graphics", &lg) } ); if(! LUA::isEmpty()) renderGLSL(g); else lua_pop(LUA::Get(), 1); } else { callback("renderOpenGL"); } } }
int main(void) { //Set the error callback glfwSetErrorCallback(error_callback); //Initialize GLFW if (!glfwInit()) { exit(EXIT_FAILURE); } glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //Declare a window object GLFWwindow* window; //Create a window and create its OpenGL context window = glfwCreateWindow(800, 800, appTitle.c_str(), NULL, NULL); //If the window couldn't be created if (!window) { fprintf(stderr, "Failed to open GLFW window.\n"); glfwTerminate(); exit(EXIT_FAILURE); } //This function makes the context of the specified window current on the calling thread. glfwMakeContextCurrent(window); //Set callbacks glfwSetKeyCallback(window, key_callback); glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); //Initialize GLEW glewExperimental = GL_TRUE; GLenum err = glewInit(); //If GLEW hasn't initialized if (err != GLEW_OK) { fprintf(stderr, "Error: %s\n", glewGetErrorString(err)); return -1; } // Output some info on the OpenGL implementation const GLubyte* glvendor = glGetString(GL_VENDOR); const GLubyte* glrenderer = glGetString(GL_RENDERER); const GLubyte* glversion = glGetString(GL_VERSION); printf("Vendor: %s\n", glvendor); printf("Renderer: %s\n", glrenderer); printf("Version: %s\n", glversion); //Set a background color renderer = glRenderer(); renderer.window = window; renderer.generateBuffers(); renderer.generateShaders(); printf("\nKeys:\n"); printf("""g"" : Toggle geometry shader\n"); printf("""w"" : Toggle wireframe\n"); printf("""+"" : increase number of subdivisions\n"); printf("""-"" : decrease number of subdivisions\n"); printf("""shift +"" : increase radius\n"); printf("""shift -"" : decrease radius\n"); double lastFPStime = glfwGetTime(); int frameCounter = 0; //Main Loop do { double thisFPStime = glfwGetTime(); frameCounter++; if (thisFPStime - lastFPStime >= 1.0) { lastFPStime = thisFPStime; std::string windowTitle = appTitle + " ("; windowTitle += std::to_string(frameCounter); windowTitle += " fps) - (c) 2014 by Sascha Willems (www.saschawillems.de)"; const char* windowCaption = windowTitle.c_str(); glfwSetWindowTitle(window, windowCaption); frameCounter = 0; } renderer.renderScene(); //Get and organize events, like keyboard and mouse input, window resizing, etc... glfwPollEvents(); } //Check if the ESC key had been pressed or if the window had been closed while (!glfwWindowShouldClose(window)); //Close OpenGL window and terminate GLFW glfwDestroyWindow(window); //Finalize and clean up GLFW glfwTerminate(); exit(EXIT_SUCCESS); }
void StelMainView::processOpenGLdiagnosticsAndWarnings(QSettings *conf, StelQGLWidget* glWidget) const #endif { #ifdef Q_OS_MAC Q_UNUSED(conf); #endif QOpenGLContext* context=glWidget->context()->contextHandle(); QSurfaceFormat format=context->format(); // These tests are not required on MacOS X #ifndef Q_OS_MAC bool openGLerror=false; if (format.renderableType()==QSurfaceFormat::OpenGL || format.renderableType()==QSurfaceFormat::OpenGLES) { qDebug() << "Detected:" << (format.renderableType()==QSurfaceFormat::OpenGL ? "OpenGL" : "OpenGL ES" ) << QString("%1.%2").arg(format.majorVersion()).arg(format.minorVersion()); } else { openGLerror=true; qDebug() << "Neither OpenGL nor OpenGL ES detected: Unsupported Format!"; } #endif QString glDriver(reinterpret_cast<const char*>(glGetString(GL_VERSION))); qDebug() << "Driver version string:" << glDriver; qDebug() << "GL vendor is" << QString(reinterpret_cast<const char*>(glGetString(GL_VENDOR))); QString glRenderer(reinterpret_cast<const char*>(glGetString(GL_RENDERER))); qDebug() << "GL renderer is" << glRenderer; // Minimal required version of OpenGL for Qt5 is 2.1 and OpenGL Shading Language may be 1.20 (or OpenGL ES is 2.0 and GLSL ES is 1.0). // As of V0.13.0..1, we use GLSL 1.10/GLSL ES 1.00 (implicitly, by omitting a #version line), but in case of using ANGLE we need hardware // detected as providing ps_3_0. // This means, usually systems with OpenGL3 support reported in the driver will work, those with reported 2.1 only will almost certainly fail. // If platform does not even support minimal OpenGL version for Qt5, then tell the user about troubles and quit from application. // This test is apparently not applicable on MacOS X due to its behaving differently from all other known OSes. // The correct way to handle driver issues on MacOS X remains however unclear for now. #ifndef Q_OS_MAC bool isMesa=glDriver.contains("Mesa", Qt::CaseInsensitive); #ifdef Q_OS_WIN bool isANGLE=glRenderer.startsWith("ANGLE", Qt::CaseSensitive); #endif if ( openGLerror || ((format.renderableType()==QSurfaceFormat::OpenGL ) && (format.version() < QPair<int, int>(2, 1)) && !isMesa) || ((format.renderableType()==QSurfaceFormat::OpenGL ) && (format.version() < QPair<int, int>(2, 0)) && isMesa) || // Mesa defaults to 2.0 but works! ((format.renderableType()==QSurfaceFormat::OpenGLES) && (format.version() < QPair<int, int>(2, 0))) ) { #ifdef Q_OS_WIN if ((!isANGLE) && (!isMesa)) qWarning() << "Oops... Insufficient OpenGL version. Please update drivers, graphics hardware, or use --angle-mode (or even --mesa-mode) option."; else if (isANGLE) qWarning() << "Oops... Insufficient OpenGL version in ANGLE. Please update drivers, graphics hardware, or use --mesa-mode option."; else qWarning() << "Oops... Insufficient OpenGL version. Mesa failed! Please send a bug report."; QMessageBox::critical(0, "Stellarium", q_("Insufficient OpenGL version. Please update drivers, graphics hardware, or use --angle-mode (or --mesa-mode) option."), QMessageBox::Abort, QMessageBox::Abort); #else qWarning() << "Oops... Insufficient OpenGL version. Please update drivers, or graphics hardware."; QMessageBox::critical(0, "Stellarium", q_("Insufficient OpenGL version. Please update drivers, or graphics hardware."), QMessageBox::Abort, QMessageBox::Abort); #endif exit(1); } #endif // This call requires OpenGL2+. QString glslString(reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION))); qDebug() << "GL Shading Language version is" << glslString; // Only give extended info if called on command line, for diagnostic. if (qApp->property("dump_OpenGL_details").toBool()) dumpOpenGLdiagnostics(); #ifdef Q_OS_WIN // If we have ANGLE, check esp. for insufficient ps_2 level. if (isANGLE) { QRegExp angleVsPsRegExp(" vs_(\\d)_(\\d) ps_(\\d)_(\\d)"); int angleVSPSpos=angleVsPsRegExp.indexIn(glRenderer); if (angleVSPSpos >-1) { float vsVersion=angleVsPsRegExp.cap(1).toFloat() + 0.1*angleVsPsRegExp.cap(2).toFloat(); float psVersion=angleVsPsRegExp.cap(3).toFloat() + 0.1*angleVsPsRegExp.cap(4).toFloat(); qDebug() << "VS Version Number detected: " << vsVersion; qDebug() << "PS Version Number detected: " << psVersion; if ((vsVersion<2.0) || (psVersion<3.0)) { openGLerror=true; qDebug() << "This is not enough: we need DirectX9 with vs_2_0 and ps_3_0 or later."; qDebug() << "You should update graphics drivers, graphics hardware, or use the --mesa-mode option."; qDebug() << "Else, please try to use an older version like 0.12.5, and try with --safe-mode"; if (conf->value("main/ignore_opengl_warning", false).toBool()) { qDebug() << "Config option main/ignore_opengl_warning found, continuing. Expect problems."; } else { qDebug() << "You can try to run in an unsupported degraded mode by ignoring the warning and continuing."; qDebug() << "But more than likely problems will persist."; QMessageBox::StandardButton answerButton= QMessageBox::critical(0, "Stellarium", q_("Your DirectX/OpenGL ES subsystem has problems. See log for details.\nIgnore and suppress this notice in the future and try to continue in degraded mode anyway?"), QMessageBox::Ignore|QMessageBox::Abort, QMessageBox::Abort); if (answerButton == QMessageBox::Abort) { qDebug() << "Aborting due to ANGLE OpenGL ES / DirectX vs or ps version problems."; exit(1); } else { qDebug() << "Ignoring all warnings, continuing without further question."; conf->setValue("main/ignore_opengl_warning", true); } } } else qDebug() << "vs/ps version is fine, we should not see a graphics problem."; } else { qDebug() << "Cannot parse ANGLE shader version string. This may indicate future problems."; qDebug() << "Please send a bug report that includes this log file and states if Stellarium runs or has problems."; } } #endif #ifndef Q_OS_MAC // Do a similar test for MESA: Ensure we have at least Mesa 10, Mesa 9 on FreeBSD (used for hardware-acceleration of AMD IGP) was reported to lose the stars. if (isMesa) { QRegExp mesaRegExp("Mesa (\\d+\\.\\d+)"); // we need only major version. Minor should always be here. Test? int mesaPos=mesaRegExp.indexIn(glDriver); if (mesaPos >-1) { float mesaVersion=mesaRegExp.cap(1).toFloat(); qDebug() << "MESA Version Number detected: " << mesaVersion; if ((mesaVersion<10.0f)) { openGLerror=true; qDebug() << "This is not enough: we need Mesa 10.0 or later."; qDebug() << "You should update graphics drivers or graphics hardware."; qDebug() << "Else, please try to use an older version like 0.12.5, and try there with --safe-mode"; if (conf->value("main/ignore_opengl_warning", false).toBool()) { qDebug() << "Config option main/ignore_opengl_warning found, continuing. Expect problems."; } else { qDebug() << "You can try to run in an unsupported degraded mode by ignoring the warning and continuing."; qDebug() << "But more than likely problems will persist."; QMessageBox::StandardButton answerButton= QMessageBox::critical(0, "Stellarium", q_("Your OpenGL/Mesa subsystem has problems. See log for details.\nIgnore and suppress this notice in the future and try to continue in degraded mode anyway?"), QMessageBox::Ignore|QMessageBox::Abort, QMessageBox::Abort); if (answerButton == QMessageBox::Abort) { qDebug() << "Aborting due to OpenGL/Mesa insufficient version problems."; exit(1); } else { qDebug() << "Ignoring all warnings, continuing without further question."; conf->setValue("main/ignore_opengl_warning", true); } } } else qDebug() << "Mesa version is fine, we should not see a graphics problem."; } else { qDebug() << "Cannot parse Mesa Driver version string. This may indicate future problems."; qDebug() << "Please send a bug report that includes this log file and states if Stellarium runs or has problems."; } } #endif // Although our shaders are only GLSL1.10, there are frequent problems with systems just at this level of programmable shaders. // If GLSL version is less than 1.30 or GLSL ES 1.00, Stellarium usually does run properly on Windows or various Linux flavours. // Depending on whatever driver/implementation details, Stellarium may crash or show only minor graphical errors. // On these systems, we show a warning panel that can be suppressed by a config option which is automatically added on first run. // Again, based on a sample size of one, Macs have been reported already to always work in this case. #ifndef Q_OS_MAC QRegExp glslRegExp("^(\\d\\.\\d\\d)"); int pos=glslRegExp.indexIn(glslString); QRegExp glslesRegExp("ES (\\d\\.\\d\\d)"); int posES=glslesRegExp.indexIn(glslString); if (pos >-1) { float glslVersion=glslRegExp.cap(1).toFloat(); qDebug() << "GLSL Version Number detected: " << glslVersion; if (glslVersion<1.3f) { openGLerror=true; qDebug() << "This is not enough: we need GLSL1.30 or later."; qDebug() << "You should update graphics drivers, graphics hardware, or use the --mesa-mode option."; qDebug() << "Else, please try to use an older version like 0.12.5, and try there with --safe-mode"; if (conf->value("main/ignore_opengl_warning", false).toBool()) { qDebug() << "Config option main/ignore_opengl_warning found, continuing. Expect problems."; } else { qDebug() << "You can try to run in an unsupported degraded mode by ignoring the warning and continuing."; qDebug() << "But more than likely problems will persist."; QMessageBox::StandardButton answerButton= QMessageBox::critical(0, "Stellarium", q_("Your OpenGL subsystem has problems. See log for details.\nIgnore and suppress this notice in the future and try to continue in degraded mode anyway?"), QMessageBox::Ignore|QMessageBox::Abort, QMessageBox::Abort); if (answerButton == QMessageBox::Abort) { qDebug() << "Aborting due to OpenGL/GLSL version problems."; exit(1); } else { qDebug() << "Ignoring all warnings, continuing without further question."; conf->setValue("main/ignore_opengl_warning", true); } } } else qDebug() << "GLSL version is fine, we should not see a graphics problem."; } else if (posES >-1) { float glslesVersion=glslesRegExp.cap(1).toFloat(); qDebug() << "GLSL ES Version Number detected: " << glslesVersion; if (glslesVersion<1.0) // TBD: is this possible at all? { openGLerror=true; qDebug() << "This is not enough: we need GLSL ES 1.00 or later."; #ifdef Q_OS_WIN qDebug() << "You should update graphics drivers, graphics hardware, or use the --mesa-mode option."; #else qDebug() << "You should update graphics drivers or graphics hardware."; #endif qDebug() << "Else, please try to use an older version like 0.12.5, and try there with --safe-mode"; if (conf->value("main/ignore_opengl_warning", false).toBool()) { qDebug() << "Config option main/ignore_opengl_warning found, continuing. Expect problems."; } else { qDebug() << "You can try to run in an unsupported degraded mode by ignoring the warning and continuing."; qDebug() << "But more than likely problems will persist."; QMessageBox::StandardButton answerButton= QMessageBox::critical(0, "Stellarium", q_("Your OpenGL ES subsystem has problems. See log for details.\nIgnore and suppress this notice in the future and try to continue in degraded mode anyway?"), QMessageBox::Ignore|QMessageBox::Abort, QMessageBox::Abort); if (answerButton == QMessageBox::Abort) { qDebug() << "Aborting due to OpenGL ES/GLSL ES version problems."; exit(1); } else { qDebug() << "Ignoring all warnings, continuing without further question."; conf->setValue("main/ignore_opengl_warning", true); } } } else { if (openGLerror) qDebug() << "GLSL ES version is OK, but there were previous errors, expect problems."; else qDebug() << "GLSL ES version is fine, we should not see a graphics problem."; } } else { qDebug() << "Cannot parse GLSL (ES) version string. This may indicate future problems."; qDebug() << "Please send a bug report that includes this log file and states if Stellarium works or has problems."; } #endif }