Add support for high graphics mode on GLES3

Also fix OpenGL-related issues on Android.

Co-authored-by: Ruslan Kabatsayev <b7.10110111@gmail.com>

Author: DreamNik

plugins/Scenery3d/src/GLFuncs.hpp

@@ -22,13 +22,13 @@
 #define GLFUNCS_HPP
 
 #include <QOpenGLContext>
+#include <StelOpenGL.hpp>
 
 #if !QT_CONFIG(opengles2)
-#include <QOpenGLFunctions_1_0>
 //! Defines some OpenGL functions not resolved through StelOpenGL (which only contains base OpenGL ES2 functions)
 //! Using the QOpenGLFunctions_*_* directly would solve this better, but it conflicts with the
 //! current StelOpenGL header dramatically.
-class GLExtFuncs : public QOpenGLFunctions_1_0
+class GLExtFuncs : public StelOpenGL::BaseFunctions
 {
 public:
 	//! Since 3.2

src/StelMainView.cpp

@@ -885,13 +885,20 @@ void StelMainView::init()
 	glInfo.supportsLuminanceTextures = format.profile() == QSurfaceFormat::CompatibilityProfile ||
 									   format.majorVersion() < 3;
 	glInfo.isGLES = format.renderableType()==QSurfaceFormat::OpenGLES;
+	glInfo.majorVersion = format.majorVersion();
 	qInfo().nospace() << "Luminance textures are " << (glInfo.supportsLuminanceTextures ? "" : "not ") << "supported";
 	glInfo.isCoreProfile = format.profile() == QSurfaceFormat::CoreProfile;
         #if defined Q_OS_HAIKU || defined Q_OS_SOLARIS
         // Haiku OS/Solaris hasn't hardware acceleration and we shouldn't use High Graphics Mode here
         glInfo.isHighGraphicsMode = false;
         #else
-	glInfo.isHighGraphicsMode = !qApp->property("onetime_force_low_graphics").toBool() && !!StelOpenGL::highGraphicsFunctions();
+	// GLES will always provide high graphics functions due to our choice of QOpenGLExtraFunctions,
+	// so we also need to check that we have at least GLES3 to enable high graphics mode.
+	// For desktop OpenGL our target version is also at least 3, so it's compatible with this check.
+	// And we do need to check that high-graphics functions are available, since GL3.0 is not sufficient.
+	glInfo.isHighGraphicsMode = glInfo.majorVersion >= 3 && !!StelOpenGL::highGraphicsFunctions();
+	if (qApp->property("onetime_force_low_graphics").toBool())
+		glInfo.isHighGraphicsMode = false;
         #endif
 	qInfo() << "Running in" << (glInfo.isHighGraphicsMode ? "High" : "Low") << "Graphics Mode";
 

src/StelMainView.hpp

@@ -85,6 +85,7 @@ class StelMainView : public QGraphicsView
 		bool isCoreProfile = false;
 		bool isHighGraphicsMode = false;
 		bool isGLES = false;
+		GLint majorVersion = 0;
 	};
 
 	StelMainView(QSettings* settings);

src/core/Dithering.cpp

@@ -61,7 +61,8 @@ QString makeDitheringShader()
 	return 1+R"(
 #line 1 101
 uniform mediump vec3 rgbMaxValue;
-uniform sampler2D ditherPattern;
+uniform mediump sampler2D ditherPattern;
+
 mediump vec3 dither(mediump vec3 c)
 {
 	c = clamp(c, 0., 1.);

src/core/StelApp.cpp

@@ -931,6 +931,7 @@ void main()
 	postProcessorUniformLocations.ditherPattern = postProcessorProgram->uniformLocation("ditherPattern");
 	postProcessorProgram->release();
 
+#if !QT_CONFIG(opengles2)
 	if(StelMainView::getInstance().getGLInformation().isHighGraphicsMode)
 	{
 		postProcessorProgramMS.reset(new QOpenGLShaderProgram);
@@ -965,11 +966,11 @@ void main()
 		postProcessorUniformLocationsMS.numMultiSamples   = postProcessorProgramMS->uniformLocation("numMultiSamples");
 		postProcessorProgramMS->release();
 	}
+#endif
 }
 
 void StelApp::highGraphicsModeDraw()
 {
-#if !QT_CONFIG(opengles2)
 	const auto targetFBO = currentFbo;
 	StelProjector::StelProjectorParams params = core->getCurrentStelProjectorParams();
 	const auto w = params.viewportXywh[2] * params.devicePixelsPerPixel;
@@ -982,11 +983,17 @@ void StelApp::highGraphicsModeDraw()
 		qInfo() << "OpenGL viewport size:" << viewport[2] << "x" << viewport[3];
 
 		qInfo().nospace() << "Creating scene FBO with size " << w << "x" << h;
+
+#if QT_CONFIG(opengles2)
+		const auto internalFormat = GL_RGBA16F;
+#else
 		const auto internalFormat = GL_RGBA16;
+#endif
 		QOpenGLFramebufferObjectFormat format;
 		format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
 		format.setInternalTextureFormat(internalFormat);
 		sceneFBO.reset(new QOpenGLFramebufferObject(w, h, format));
+#if !QT_CONFIG(opengles2)
 		GLint maxSamples = 1;
 		GL(gl->glGetIntegerv(GL_MAX_SAMPLES, &maxSamples));
 		const auto samples = confSettings->value("video/multisampling", 0).toInt();
@@ -1025,6 +1032,7 @@ void StelApp::highGraphicsModeDraw()
 				                      << status;
 			}
 		}
+#endif
 	}
 
 	if(sceneMultisampledFBO)
@@ -1090,7 +1098,6 @@ void StelApp::highGraphicsModeDraw()
 	GL(gl->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
 	GL(gl->glDisable(GL_BLEND));
 	postProcessorVAO->release();
-#endif
 }
 
 //! Main drawing function called at each frame

src/core/StelOpenGL.cpp

@@ -67,80 +67,67 @@ QByteArray StelOpenGL::globalShaderPrefix(const ShaderType type)
 {
 	const auto& glInfo = StelMainView::getInstance().getGLInformation();
 
-	if(glInfo.isHighGraphicsMode)
+	QByteArray prefix;
+
+	if (glInfo.isHighGraphicsMode)
 	{
-		if(type == VERTEX_SHADER)
-		{
-			static const QByteArray prefix = 1+R"(
-#version 330
-#define ATTRIBUTE in
-#define VARYING out
-#define texture2D(a,b) texture(a,b)
-#define texture2D_3(a,b,c) texture(a,b,c)
-#define texture2DProj(a,b) textureProj(a,b)
-#define texture2DProj_3(a,b,c) textureProj(a,b,c)
-#define shadow2D_x(a,b) texture(a,b)
-#define shadow2DProj_x(a,b) textureProj(a,b)
-#define textureCube(a,b) texture(a,b)
-#define textureCube_3(a,b,c) texture(a,b,c)
-#line 1
-)";
-			return prefix;
-		}
-		else // FRAGMENT_SHADER
-		{
-			static const QByteArray prefix = 1+R"(
-#version 330
-#define VARYING in
-out vec4 FRAG_COLOR;
-#define texture2D(a,b) texture(a,b)
-#define texture2D_3(a,b,c) texture(a,b,c)
-#define texture2DProj(a,b) textureProj(a,b)
-#define texture2DProj_3(a,b,c) textureProj(a,b,c)
-#define shadow2D_x(a,b) texture(a,b)
-#define shadow2DProj_x(a,b) textureProj(a,b)
-#define textureCube(a,b) texture(a,b)
-#define textureCube_3(a,b,c) texture(a,b,c)
-#define textureGrad_SUPPORTED
-#line 1
-)";
-			return prefix;
-		}
-	}
+		if (glInfo.isGLES)
+			prefix += "#version 300 es\n";
+		else
+			prefix += "#version 330\n";
 
-	if(type == VERTEX_SHADER)
+		prefix += "#define texture2D(a,b) texture(a,b)\n"
+			  "#define texture2D_3(a,b,c) texture(a,b,c)\n"
+			  "#define texture2DProj(a,b) textureProj(a,b)\n"
+			  "#define texture2DProj_3(a,b,c) textureProj(a,b,c)\n"
+			  "#define shadow2D_x(a,b) texture(a,b)\n"
+			  "#define shadow2DProj_x(a,b) textureProj(a,b)\n"
+			  "#define textureCube(a,b) texture(a,b)\n"
+			  "#define textureCube_3(a,b,c) texture(a,b,c)\n";
+	}
+	else
 	{
-		static const QByteArray prefix = 1+R"(
-#define ATTRIBUTE attribute
-#define VARYING varying
-#define texture2D_3(a,b,c) texture2D(a,b,c)
-#define texture2DProj_3(a,b,c) texture2DProj(a,b,c)
-#define shadow2D_x(a,b) shadow2D(a,b).x
-#define shadow2DProj_x(a,b) shadow2DProj(a,b).x
-#define textureCube_3(a,b,c) textureCube(a,b,c)
-#line 1
-)";
-		return prefix;
+		prefix += "#define texture2D_3(a,b,c) texture2D(a,b,c)\n"
+			  "#define texture2DProj_3(a,b,c) texture2DProj(a,b,c)\n"
+			  "#define shadow2D_x(a,b) shadow2D(a,b).x\n"
+			  "#define shadow2DProj_x(a,b) shadow2DProj(a,b).x\n"
+			  "#define textureCube_3(a,b,c) textureCube(a,b,c)\n";
 	}
-	else // FRAGMENT_SHADER
+
+	if (glInfo.isGLES)
+		prefix += "precision mediump float;\n";
+
+	switch (type)
 	{
-		static const QByteArray prefix = 1+R"(
-#define VARYING varying
-#define FRAG_COLOR gl_FragColor
-#define texture2D_3(a,b,c) texture2D(a,b,c)
-#define texture2DProj_3(a,b,c) texture2DProj(a,b,c)
-#define shadow2D_x(a,b) shadow2D(a,b).x
-#define shadow2DProj_x(a,b) shadow2DProj(a,b).x
-#define textureCube_3(a,b,c) textureCube(a,b,c)
-#line 1
-)";
-		if(glInfo.isGLES)
-			return "precision mediump float;\n" + prefix;
-		return prefix;
+	case VERTEX_SHADER:
+		if (glInfo.isHighGraphicsMode)
+			prefix += "#define ATTRIBUTE in\n"
+				  "#define VARYING out\n";
+		else
+			prefix += "#define ATTRIBUTE attribute\n"
+				  "#define VARYING varying\n";
+		break;
+
+	case FRAGMENT_SHADER:
+		if (glInfo.isHighGraphicsMode)
+			prefix += "#define VARYING in\n"
+				  "#define textureGrad_SUPPORTED\n"
+				  "out highp vec4 FRAG_COLOR;\n";
+		else
+			prefix += "#define VARYING varying\n"
+				  "#define FRAG_COLOR gl_FragColor\n";
+		break;
+
+	case GEOMETRY_SHADER: break;
 	}
+
+	prefix += "#line 1\n";
+
+	return prefix;
 }
 
-QOpenGLFunctions_3_3_Core* StelOpenGL::highGraphicsFunctions()
+
+auto StelOpenGL::highGraphicsFunctions() -> HighGraphicsFunctions*
 {
 #if !QT_CONFIG(opengles2)
 # if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
@@ -149,6 +136,6 @@ QOpenGLFunctions_3_3_Core* StelOpenGL::highGraphicsFunctions()
 	return QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_3_Core>();
 # endif
 #else
-	return nullptr;
+	return QOpenGLContext::currentContext()->extraFunctions();
 #endif
 }

src/core/StelOpenGL.hpp

@@ -35,11 +35,29 @@
 # define GL(line) line
 #endif
 
-class QOpenGLFunctions_3_3_Core;
+#if defined(Q_OS_ANDROID)
+# include <QOpenGLExtraFunctions>
+# include <GLES3/gl32.h>
+# define APIENTRY
+#elif QT_CONFIG(opengles2)
+# include <QOpenGLExtraFunctions>
+#else
+# include <QOpenGLFunctions_1_0>
+# include <QOpenGLFunctions_3_3_Core>
+#endif
 
 //! Namespace containing some OpenGL helpers
 namespace StelOpenGL
 {
+
+#if defined(Q_OS_ANDROID) || QT_CONFIG(opengles2)
+	using BaseFunctions = QOpenGLExtraFunctions;
+	using HighGraphicsFunctions = QOpenGLExtraFunctions;
+#else
+	using BaseFunctions = QOpenGLFunctions_1_0;
+	using HighGraphicsFunctions = QOpenGLFunctions_3_3_Core;
+#endif
+
 	//! The main context as created by the StelMainView (only used for debugging)
 	extern QOpenGLContext* mainContext;
 
@@ -54,12 +72,13 @@ namespace StelOpenGL
 	{
 		VERTEX_SHADER,
 		FRAGMENT_SHADER,
+		GEOMETRY_SHADER,
 	};
 	//! Returns a prefix containing \#version directive and a few defines for
 	//  the GLSL version supported in current GL context.
 	QByteArray globalShaderPrefix(ShaderType);
 	//! Returns high-graphics OpenGL functions, for use in non-ANGLE/CompatProfile/etc. modes.
-	QOpenGLFunctions_3_3_Core* highGraphicsFunctions();
+	HighGraphicsFunctions* highGraphicsFunctions();
 }
 
 // This is still needed for the ARM platform (armhf)

src/core/StelPainter.cpp

@@ -2376,14 +2376,13 @@ void main()
 	texturesColorShaderVars.texture = texturesColorShaderProgram->uniformLocation("tex");
 	texturesColorShaderVars.saturation = texturesColorShaderProgram->uniformLocation("saturation");
 
-	if(StelMainView::getInstance().getGLInformation().isCoreProfile)
+	const auto& glInfo = StelMainView::getInstance().getGLInformation();
+	if(glInfo.isCoreProfile && glInfo.isHighGraphicsMode && !glInfo.isGLES)
 	{
 		// In Core profile wide lines (width>1px) are not supported, so this shader is used to render them with triangles.
 
 		// Common template for the geometry shader
-		const QByteArray geomSrc = 1+R"(
-#version 330
-
+		const QByteArray geomSrc = StelOpenGL::globalShaderPrefix(StelOpenGL::GEOMETRY_SHADER) + R"(
 layout(lines) in;
 layout(triangle_strip, max_vertices=4) out;
 uniform vec2 viewportSize;
@@ -2436,9 +2435,8 @@ void main()
 
 		// First a basic shader using constant line color
 		QOpenGLShader wideLineVertShader(QOpenGLShader::Vertex);
-		wideLineVertShader.compileSourceCode(1+R"(
-#version 330
-in vec3 vertex;
+		wideLineVertShader.compileSourceCode(StelOpenGL::globalShaderPrefix(StelOpenGL::VERTEX_SHADER) + R"(
+ATTRIBUTE vec3 vertex;
 uniform mat4 projectionMatrix;
 void main()
 {
@@ -2454,13 +2452,11 @@ void main()
 			qWarning().noquote() << "StelPainter: Warnings while compiling wide line geometry shader: " << wideLineGeomShader.log();
 
 		QOpenGLShader wideLineFragShader(QOpenGLShader::Fragment);
-		wideLineFragShader.compileSourceCode(1+R"(
-#version 330
+		wideLineFragShader.compileSourceCode(StelOpenGL::globalShaderPrefix(StelOpenGL::FRAGMENT_SHADER) + R"(
 uniform vec4 color;
-out vec4 outputColor;
 void main()
 {
-    outputColor = color;
+    FRAG_COLOR = color;
 }
 )");
 		if (!wideLineFragShader.log().isEmpty())
@@ -2478,16 +2474,15 @@ void main()
 
 		// Now a version of the shader that supports color interpolated along the line
 		QOpenGLShader colorfulWideLineVertShader(QOpenGLShader::Vertex);
-		colorfulWideLineVertShader.compileSourceCode(1+R"(
-#version 330
-in vec3 vertex;
-in vec4 color;
-out vec4 varyingColor;
+		colorfulWideLineVertShader.compileSourceCode(StelOpenGL::globalShaderPrefix(StelOpenGL::VERTEX_SHADER) + R"(
+ATTRIBUTE vec3 vertex;
+ATTRIBUTE vec4 color;
+VARYING vec4 varyingColor;
 uniform mat4 projectionMatrix;
 void main()
 {
     gl_Position = projectionMatrix*vec4(vertex, 1.);
-	varyingColor = color;
+    varyingColor = color;
 }
 )");
 		if (!colorfulWideLineVertShader.log().isEmpty())
@@ -2499,13 +2494,11 @@ void main()
 			qWarning().noquote() << "StelPainter: Warnings while compiling colorful wide line geometry shader: " << colorfulWideLineGeomShader.log();
 
 		QOpenGLShader colorfulWideLineFragShader(QOpenGLShader::Fragment);
-		colorfulWideLineFragShader.compileSourceCode(1+R"(
-#version 330
-in vec4 geomColor;
-out vec4 outputColor;
+		colorfulWideLineFragShader.compileSourceCode(StelOpenGL::globalShaderPrefix(StelOpenGL::FRAGMENT_SHADER) + R"(
+VARYING vec4 geomColor;
 void main()
 {
-    outputColor = geomColor;
+    FRAG_COLOR = geomColor;
 }
 )");
 		if (!colorfulWideLineFragShader.log().isEmpty())