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
}
