Restore legacy OpenGL 2.1 support.

OpenRA.Game/Graphics/PlatformInterfaces.cs

@@ -19,6 +19,7 @@ namespace OpenRA
 	{
 		Modern,
 		Embedded,
+		Legacy
 	}
 
 	public interface IPlatform

OpenRA.Game/Settings.cs

@@ -177,7 +177,8 @@ namespace OpenRA
 
 		[Desc("Preferred OpenGL profile to use.",
 			"Modern: OpenGL Core Profile 3.2 or greater.",
-			"Embedded: OpenGL ES 3.0 or greater.")]
+			"Embedded: OpenGL ES 3.0 or greater.",
+			"Legacy: OpenGL 2.1 with framebuffer_object extension.")]
 		public GLProfile GLProfile = GLProfile.Modern;
 
 		public int BatchSize = 8192;

OpenRA.Platforms.Default/OpenGL.cs

@@ -478,7 +478,7 @@ namespace OpenRA.Platforms.Default
 
 		#endregion
 
-		public static void Initialize()
+		public static void Initialize(bool preferLegacyProfile)
 		{
 			try
 			{
@@ -488,13 +488,14 @@ namespace OpenRA.Platforms.Default
 				glGetError = Bind<GetError>("glGetError");
 				glGetStringInternal = Bind<GetString>("glGetString");
 				glGetStringiInternal = Bind<GetStringi>("glGetStringi");
+				glGetIntegerv = Bind<GetIntegerv>("glGetIntegerv");
 			}
 			catch (Exception e)
 			{
 				throw new InvalidProgramException("Failed to initialize low-level OpenGL bindings. GPU information is not available.", e);
 			}
 
-			if (!DetectGLFeatures())
+			if (!DetectGLFeatures(preferLegacyProfile))
 			{
 				WriteGraphicsLog("Unsupported OpenGL version: " + glGetString(GL_VERSION));
 				throw new InvalidProgramException("OpenGL Version Error: See graphics.log for details.");
@@ -542,7 +543,6 @@ namespace OpenRA.Platforms.Default
 				glViewport = Bind<Viewport>("glViewport");
 				glClear = Bind<Clear>("glClear");
 				glClearColor = Bind<ClearColor>("glClearColor");
-				glGetIntegerv = Bind<GetIntegerv>("glGetIntegerv");
 				glFinish = Bind<Finish>("glFinish");
 				glCreateProgram = Bind<CreateProgram>("glCreateProgram");
 				glUseProgram = Bind<UseProgram>("glUseProgram");
@@ -571,10 +571,7 @@ namespace OpenRA.Platforms.Default
 				glBufferData = Bind<BufferData>("glBufferData");
 				glBufferSubData = Bind<BufferSubData>("glBufferSubData");
 				glDeleteBuffers = Bind<DeleteBuffers>("glDeleteBuffers");
-				glGenVertexArrays = Bind<GenVertexArrays>("glGenVertexArrays");
-				glBindVertexArray = Bind<BindVertexArray>("glBindVertexArray");
 				glBindAttribLocation = Bind<BindAttribLocation>("glBindAttribLocation");
-				glBindFragDataLocation = Bind<BindFragDataLocation>("glBindFragDataLocation");
 				glVertexAttribPointer = Bind<VertexAttribPointer>("glVertexAttribPointer");
 				glEnableVertexAttribArray = Bind<EnableVertexAttribArray>("glEnableVertexAttribArray");
 				glDisableVertexAttribArray = Bind<DisableVertexAttribArray>("glDisableVertexAttribArray");
@@ -594,6 +591,12 @@ namespace OpenRA.Platforms.Default
 				glGetTexImage = Bind<GetTexImage>("glGetTexImage");
 				glTexParameteri = Bind<TexParameteri>("glTexParameteri");
 				glTexParameterf = Bind<TexParameterf>("glTexParameterf");
+
+				if (Profile != GLProfile.Legacy)
+				{
+					glGenVertexArrays = Bind<GenVertexArrays>("glGenVertexArrays");
+					glBindVertexArray = Bind<BindVertexArray>("glBindVertexArray");
+					glBindFragDataLocation = Bind<BindFragDataLocation>("glBindFragDataLocation");
 					glGenFramebuffers = Bind<GenFramebuffers>("glGenFramebuffers");
 					glBindFramebuffer = Bind<BindFramebuffer>("glBindFramebuffer");
 					glFramebufferTexture2D = Bind<FramebufferTexture2D>("glFramebufferTexture2D");
@@ -605,6 +608,23 @@ namespace OpenRA.Platforms.Default
 					glFramebufferRenderbuffer = Bind<FramebufferRenderbuffer>("glFramebufferRenderbuffer");
 					glCheckFramebufferStatus = Bind<CheckFramebufferStatus>("glCheckFramebufferStatus");
 				}
+				else
+				{
+					glGenVertexArrays = null;
+					glBindVertexArray = null;
+					glBindFragDataLocation = null;
+					glGenFramebuffers = Bind<GenFramebuffers>("glGenFramebuffersEXT");
+					glBindFramebuffer = Bind<BindFramebuffer>("glBindFramebufferEXT");
+					glFramebufferTexture2D = Bind<FramebufferTexture2D>("glFramebufferTexture2DEXT");
+					glDeleteFramebuffers = Bind<DeleteFramebuffers>("glDeleteFramebuffersEXT");
+					glGenRenderbuffers = Bind<GenRenderbuffers>("glGenRenderbuffersEXT");
+					glBindRenderbuffer = Bind<BindRenderbuffer>("glBindRenderbufferEXT");
+					glRenderbufferStorage = Bind<RenderbufferStorage>("glRenderbufferStorageEXT");
+					glDeleteRenderbuffers = Bind<DeleteRenderbuffers>("glDeleteRenderbuffersEXT");
+					glFramebufferRenderbuffer = Bind<FramebufferRenderbuffer>("glFramebufferRenderbufferEXT");
+					glCheckFramebufferStatus = Bind<CheckFramebufferStatus>("glCheckFramebufferStatusEXT");
+				}
+			}
 			catch (Exception e)
 			{
 				WriteGraphicsLog("Failed to initialize OpenGL bindings.\nInner exception was: {0}".F(e));
@@ -617,7 +637,7 @@ namespace OpenRA.Platforms.Default
 			return (T)(object)Marshal.GetDelegateForFunctionPointer(SDL.SDL_GL_GetProcAddress(name), typeof(T));
 		}
 
-		public static bool DetectGLFeatures()
+		public static bool DetectGLFeatures(bool preferLegacyProfile)
 		{
 			var hasValidConfiguration = false;
 			try
@@ -654,6 +674,15 @@ namespace OpenRA.Platforms.Default
 				var hasDebugMessagesCallback = SDL.SDL_GL_ExtensionSupported("GL_KHR_debug") == SDL.SDL_bool.SDL_TRUE;
 				if (hasDebugMessagesCallback)
 					Features |= GLFeatures.DebugMessagesCallback;
+
+				if (preferLegacyProfile || (major == 2 && minor == 1) || (major == 3 && minor < 2))
+				{
+					if (SDL.SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object") == SDL.SDL_bool.SDL_TRUE)
+					{
+						hasValidConfiguration = true;
+						Profile = GLProfile.Legacy;
+					}
+				}
 			}
 			catch (Exception) { }
 
@@ -680,11 +709,16 @@ namespace OpenRA.Platforms.Default
 			Log.Write("graphics", "Shader Version: {0}", glGetString(GL_SHADING_LANGUAGE_VERSION));
 			Log.Write("graphics", "Available extensions:");
 
+			if (Profile != GLProfile.Legacy)
+			{
 				int extensionCount;
 				glGetIntegerv(GL_NUM_EXTENSIONS, out extensionCount);
 				for (var i = 0; i < extensionCount; i++)
 					Log.Write("graphics", glGetStringi(GL_EXTENSIONS, (uint)i));
 			}
+			else
+				Log.Write("graphics", glGetString(GL_EXTENSIONS));
+		}
 
 		public static void CheckGLError()
 		{

OpenRA.Platforms.Default/Sdl2GraphicsContext.cs

@@ -35,14 +35,17 @@ namespace OpenRA.Platforms.Default
 			if (context == IntPtr.Zero || SDL.SDL_GL_MakeCurrent(window.Window, context) < 0)
 				throw new InvalidOperationException("Can not create OpenGL context. (Error: {0})".F(SDL.SDL_GetError()));
 
-			OpenGL.Initialize();
+			OpenGL.Initialize(window.GLProfile == GLProfile.Legacy);
-
-			uint vao;
 			OpenGL.CheckGLError();
+
+			if (OpenGL.Profile != GLProfile.Legacy)
+			{
+				uint vao;
 				OpenGL.glGenVertexArrays(1, out vao);
 				OpenGL.CheckGLError();
 				OpenGL.glBindVertexArray(vao);
 				OpenGL.CheckGLError();
+			}
 
 			OpenGL.glEnableVertexAttribArray(Shader.VertexPosAttributeIndex);
 			OpenGL.CheckGLError();

OpenRA.Platforms.Default/Sdl2PlatformWindow.cs

@@ -151,9 +151,9 @@ namespace OpenRA.Platforms.Default
 				// We first need to query the available profiles on Windows/Linux.
 				// On macOS, known/consistent OpenGL support is provided by the OS.
 				if (Platform.CurrentPlatform == PlatformType.OSX)
-					supportedProfiles = new[] { GLProfile.Modern };
+					supportedProfiles = new[] { GLProfile.Modern, GLProfile.Legacy };
 				else
-					supportedProfiles = new[] { GLProfile.Modern, GLProfile.Embedded }
+					supportedProfiles = new[] { GLProfile.Modern, GLProfile.Embedded, GLProfile.Legacy }
 						.Where(CanCreateGLWindow)
 						.ToArray();
 
@@ -487,6 +487,10 @@ namespace OpenRA.Platforms.Default
 					SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_MINOR_VERSION, 0);
 					SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_PROFILE_MASK, (int)SDL.SDL_GLprofile.SDL_GL_CONTEXT_PROFILE_ES);
 					break;
+				case GLProfile.Legacy:
+					SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_MAJOR_VERSION, 2);
+					SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_MINOR_VERSION, 1);
+					break;
 			}
 		}
 

OpenRA.Platforms.Default/Shader.cs

@@ -23,6 +23,7 @@ namespace OpenRA.Platforms.Default
 		public const int TexMetadataAttributeIndex = 2;
 
 		readonly Dictionary<string, int> samplers = new Dictionary<string, int>();
+		readonly Dictionary<int, int> legacySizeUniforms = new Dictionary<int, int>();
 		readonly Dictionary<int, ITexture> textures = new Dictionary<int, ITexture>();
 		readonly Queue<int> unbindTextures = new Queue<int>();
 		readonly uint program;
@@ -33,7 +34,9 @@ namespace OpenRA.Platforms.Default
 			var filename = Path.Combine(Platform.GameDir, "glsl", name + "." + ext);
 			var code = File.ReadAllText(filename);
 
-			var version = OpenGL.Profile == GLProfile.Embedded ? "300 es" : "140";
+			var version = OpenGL.Profile == GLProfile.Embedded ? "300 es" :
+				OpenGL.Profile == GLProfile.Legacy ? "120" : "140";
+
 			code = code.Replace("{VERSION}", version);
 
 			var shader = OpenGL.glCreateShader(type);
@@ -80,8 +83,12 @@ namespace OpenRA.Platforms.Default
 			OpenGL.CheckGLError();
 			OpenGL.glBindAttribLocation(program, TexMetadataAttributeIndex, "aVertexTexMetadata");
 			OpenGL.CheckGLError();
+
+			if (OpenGL.Profile != GLProfile.Legacy)
+			{
 				OpenGL.glBindFragDataLocation(program, 0, "fragColor");
 				OpenGL.CheckGLError();
+			}
 
 			OpenGL.glAttachShader(program, vertexShader);
 			OpenGL.CheckGLError();
@@ -132,6 +139,13 @@ namespace OpenRA.Platforms.Default
 					OpenGL.glUniform1i(loc, nextTexUnit);
 					OpenGL.CheckGLError();
 
+					if (OpenGL.Profile == GLProfile.Legacy)
+					{
+						var sizeLoc = OpenGL.glGetUniformLocation(program, sampler + "Size");
+						if (sizeLoc >= 0)
+							legacySizeUniforms.Add(nextTexUnit, sizeLoc);
+					}
+
 					nextTexUnit++;
 				}
 			}
@@ -146,13 +160,21 @@ namespace OpenRA.Platforms.Default
 			// bind the textures
 			foreach (var kv in textures)
 			{
-				var id = ((ITextureInternal)kv.Value).ID;
+				var texture = (ITextureInternal)kv.Value;
 
 				// Evict disposed textures from the cache
-				if (OpenGL.glIsTexture(id))
+				if (OpenGL.glIsTexture(texture.ID))
 				{
 					OpenGL.glActiveTexture(OpenGL.GL_TEXTURE0 + kv.Key);
-					OpenGL.glBindTexture(OpenGL.GL_TEXTURE_2D, id);
+					OpenGL.glBindTexture(OpenGL.GL_TEXTURE_2D, texture.ID);
+
+					// Work around missing textureSize GLSL function by explicitly tracking sizes in a uniform
+					int param;
+					if (OpenGL.Profile == GLProfile.Legacy && legacySizeUniforms.TryGetValue(kv.Key, out param))
+					{
+						OpenGL.glUniform2f(param, texture.Size.Width, texture.Size.Height);
+						OpenGL.CheckGLError();
+					}
 				}
 				else
 					unbindTextures.Enqueue(kv.Key);

glsl/combined.frag

@@ -3,8 +3,6 @@
 precision mediump float;
 #endif
 
-in vec4 vColor;
-
 uniform sampler2D Texture0;
 uniform sampler2D Texture1;
 uniform sampler2D Texture2;
@@ -18,6 +16,27 @@ uniform bool EnableDepthPreview;
 uniform float DepthTextureScale;
 uniform float AntialiasPixelsPerTexel;
 
+#if __VERSION__ == 120
+varying vec4 vTexCoord;
+varying vec2 vTexMetadata;
+varying vec4 vChannelMask;
+varying vec4 vDepthMask;
+varying vec2 vTexSampler;
+
+varying vec4 vColorFraction;
+varying vec4 vRGBAFraction;
+varying vec4 vPalettedFraction;
+
+uniform vec2 Texture0Size;
+uniform vec2 Texture1Size;
+uniform vec2 Texture2Size;
+uniform vec2 Texture3Size;
+uniform vec2 Texture4Size;
+uniform vec2 Texture5Size;
+uniform vec2 Texture6Size;
+#else
+in vec4 vColor;
+
 in vec4 vTexCoord;
 in vec2 vTexMetadata;
 in vec4 vChannelMask;
@@ -29,6 +48,7 @@ in vec4 vRGBAFraction;
 in vec4 vPalettedFraction;
 
 out vec4 fragColor;
+#endif
 
 float jet_r(float x)
 {
@@ -45,6 +65,43 @@ float jet_b(float x)
 	return x < 0.3 ? 4.0 * x + 0.5 : -4.0 * x + 2.5;
 }
 
+#if __VERSION__ == 120
+vec2 Size(float samplerIndex)
+{
+	if (samplerIndex < 0.5)
+		return Texture0Size;
+	else if (samplerIndex < 1.5)
+		return Texture1Size;
+	else if (samplerIndex < 2.5)
+		return Texture2Size;
+	else if (samplerIndex < 3.5)
+		return Texture3Size;
+	else if (samplerIndex < 4.5)
+		return Texture4Size;
+	else if (samplerIndex < 5.5)
+		return Texture5Size;
+
+	return Texture6Size;
+}
+
+vec4 Sample(float samplerIndex, vec2 pos)
+{
+	if (samplerIndex < 0.5)
+		return texture2D(Texture0, pos);
+	else if (samplerIndex < 1.5)
+		return texture2D(Texture1, pos);
+	else if (samplerIndex < 2.5)
+		return texture2D(Texture2, pos);
+	else if (samplerIndex < 3.5)
+		return texture2D(Texture3, pos);
+	else if (samplerIndex < 4.5)
+		return texture2D(Texture4, pos);
+	else if (samplerIndex < 5.5)
+		return texture2D(Texture5, pos);
+
+	return texture2D(Texture6, pos);
+}
+#else
 ivec2 Size(float samplerIndex)
 {
 	if (samplerIndex < 0.5)
@@ -80,6 +137,7 @@ vec4 Sample(float samplerIndex, vec2 pos)
 
 	return texture(Texture6, pos);
 }
+#endif
 
 vec4 SamplePalettedBilinear(float samplerIndex, vec2 coords, vec2 textureSize)
 {
@@ -93,10 +151,17 @@ vec4 SamplePalettedBilinear(float samplerIndex, vec2 coords, vec2 textureSize)
 	vec4 x3 = Sample(samplerIndex, tl + vec2(0., px.y));
 	vec4 x4 = Sample(samplerIndex, tl + px);
 
+	#if __VERSION__ == 120
+	vec4 c1 = texture2D(Palette, vec2(dot(x1, vChannelMask), vTexMetadata.s));
+	vec4 c2 = texture2D(Palette, vec2(dot(x2, vChannelMask), vTexMetadata.s));
+	vec4 c3 = texture2D(Palette, vec2(dot(x3, vChannelMask), vTexMetadata.s));
+	vec4 c4 = texture2D(Palette, vec2(dot(x4, vChannelMask), vTexMetadata.s));
+	#else
 	vec4 c1 = texture(Palette, vec2(dot(x1, vChannelMask), vTexMetadata.s));
 	vec4 c2 = texture(Palette, vec2(dot(x2, vChannelMask), vTexMetadata.s));
 	vec4 c3 = texture(Palette, vec2(dot(x3, vChannelMask), vTexMetadata.s));
 	vec4 c4 = texture(Palette, vec2(dot(x4, vChannelMask), vTexMetadata.s));
+	#endif
 
 	return mix(mix(c1, c2, interp.x), mix(c3, c4, interp.x), interp.y);
 }
@@ -127,7 +192,11 @@ void main()
 	{
 		vec4 x = Sample(vTexSampler.s, coords);
 		vec2 p = vec2(dot(x, vChannelMask), vTexMetadata.s);
+		#if __VERSION__ == 120
+		c = vPalettedFraction * texture2D(Palette, p) + vRGBAFraction * x + vColorFraction * vTexCoord;
+		#else
 		c = vPalettedFraction * texture(Palette, p) + vRGBAFraction * x + vColorFraction * vTexCoord;
+		#endif
 	}
 
 	// Discard any transparent fragments (both color and depth)
@@ -150,8 +219,16 @@ void main()
 		float r = clamp(jet_r(x), 0.0, 1.0);
 		float g = clamp(jet_g(x), 0.0, 1.0);
 		float b = clamp(jet_b(x), 0.0, 1.0);
+		#if __VERSION__ == 120
+		gl_FragColor = vec4(r, g, b, 1.0);
+		#else
 		fragColor = vec4(r, g, b, 1.0);
+		#endif
 	}
 	else
+	#if __VERSION__ == 120
+		gl_FragColor = c;
+		#else
 		fragColor = c;
+		#endif
 }

glsl/combined.vert

@@ -3,6 +3,21 @@
 uniform vec3 Scroll;
 uniform vec3 r1, r2;
 
+#if __VERSION__ == 120
+attribute vec4 aVertexPosition;
+attribute vec4 aVertexTexCoord;
+attribute vec2 aVertexTexMetadata;
+
+varying vec4 vTexCoord;
+varying vec2 vTexMetadata;
+varying vec4 vChannelMask;
+varying vec4 vDepthMask;
+varying vec2 vTexSampler;
+
+varying vec4 vColorFraction;
+varying vec4 vRGBAFraction;
+varying vec4 vPalettedFraction;
+#else
 in vec4 aVertexPosition;
 in vec4 aVertexTexCoord;
 in vec2 aVertexTexMetadata;
@@ -16,6 +31,7 @@ out vec2 vTexSampler;
 out vec4 vColorFraction;
 out vec4 vRGBAFraction;
 out vec4 vPalettedFraction;
+#endif
 
 vec4 UnpackChannelAttributes(float x)
 {

glsl/model.frag

@@ -9,13 +9,30 @@ uniform vec2 PaletteRows;
 uniform vec4 LightDirection;
 uniform vec3 AmbientLight, DiffuseLight;
 
+#if __VERSION__ == 120
+varying vec4 vTexCoord;
+varying vec4 vChannelMask;
+varying vec4 vNormalsMask;
+#else
 in vec4 vTexCoord;
 in vec4 vChannelMask;
 in vec4 vNormalsMask;
 out vec4 fragColor;
+#endif
 
 void main()
 {
+	#if __VERSION__ == 120
+	vec4 x = texture2D(DiffuseTexture, vTexCoord.st);
+	vec4 color = texture2D(Palette, vec2(dot(x, vChannelMask), PaletteRows.x));
+	if (color.a < 0.01)
+		discard;
+
+	vec4 y = texture2D(DiffuseTexture, vTexCoord.pq);
+	vec4 normal = (2.0 * texture2D(Palette, vec2(dot(y, vNormalsMask), PaletteRows.y)) - 1.0);
+	vec3 intensity = AmbientLight + DiffuseLight * max(dot(normal, LightDirection), 0.0);
+	gl_FragColor = vec4(intensity * color.rgb, color.a);
+	#else
 	vec4 x = texture(DiffuseTexture, vTexCoord.st);
 	vec4 color = texture(Palette, vec2(dot(x, vChannelMask), PaletteRows.x));
 	if (color.a < 0.01)
@@ -25,4 +42,5 @@ void main()
 	vec4 normal = (2.0 * texture(Palette, vec2(dot(y, vNormalsMask), PaletteRows.y)) - 1.0);
 	vec3 intensity = AmbientLight + DiffuseLight * max(dot(normal, LightDirection), 0.0);
 	fragColor = vec4(intensity * color.rgb, color.a);
+	#endif
 }

glsl/model.vert

@@ -3,12 +3,21 @@
 uniform mat4 View;
 uniform mat4 TransformMatrix;
 
+#if __VERSION__ == 120
+attribute vec4 aVertexPosition;
+attribute vec4 aVertexTexCoord;
+attribute vec2 aVertexTexMetadata;
+varying vec4 vTexCoord;
+varying vec4 vChannelMask;
+varying vec4 vNormalsMask;
+#else
 in vec4 aVertexPosition;
 in vec4 aVertexTexCoord;
 in vec2 aVertexTexMetadata;
 out vec4 vTexCoord;
 out vec4 vChannelMask;
 out vec4 vNormalsMask;
+#endif
 
 vec4 DecodeMask(float x)
 {