Least supported OpenGL ES version?

[louwers]

The rendering modularization effort has kicked off. As part of this effort, a team of graphics experts led by @sjg-wdw is refactoring the internals of MapLibre Native to allow for alternate rendering backends, preparing the library for the future.

The team would benefit greatly from modern OpenGL ES features. That is why I would like to kick off a discussion: what is the least supported OpenGL ES version MapLibre Native should support? The suggestion is to bump the minimum required version to OpenGL ES 3.0.

---

Android

For Android, here are some numbers from Google.

On iOS OpenGL ES 3.0 has been supported since Apple's A7 GPU and later.

[sjg-wdw]

It's true that iOS doesn't support anything beyond OpenGL ES 3.0, but that's probably good enough to maintain compatibility for the near term.

Is there anything we can't live without in 3.1, at least for a few months?

[mwilsnd]

You can see a list of changes in 3.1 here (Appendix E.1).
Main changes are compute shaders, SSBOs and all related facilities for writing compute (atomics, image load/store, indirect commands).

[sjg-wdw]

We used 3.0 for a long time on iOS so my sense is we can live without those things in MapLibre until we get Metal working.

However for Android I wonder if we might use compute shaders and SSBOs to move the data driven parameters into their own shader steps. Something to consider for an OpenGL upgrade on Android at some point.

[mwilsnd]

There is also this page which outlines the minimum API level at which a version of OpenGL ES is potentially available. The main concern I have is with older and more affordable Android devices that may not support 3.1. I'm not familiar enough with the Android ecosystem to determine the exact state of API support for devices still in circulation.

[sjg-wdw]

I think requiring 3.1 might be a step too far at this point. But using compute shaders for the data driven rendering would simplify things a lot. Particularly if we use that approach for Metal as well. Those are separate implementations, of course, but if they echo each other it makes for easier development.

Let's start with requiring 3.0 as the baseline.
Advantages:

• It increases the number of uniforms and vertex arrays.
• Lets us set defaults on the vertex arrays, removing the uniform #ifdefs
• Uniform Buffer Object support

Disadvantages:

• Lose 2.0 support.
• Shaders are more complex since they're data driven still

How about using 3.1 as the baseline.
Advantages:

• Compute shaders and SSBOs. Particularly for data driven styling, though that would need to be tested.
• Indirect draw commands. Maybe not right now, but could be good for an OpenGL based sprint.
• Shaders are simpler if they're just getting inputs from compute shaders for data driven values.

Disadvantages:

• We lose some chunk of Android devices.
• We won't have a working iOS version while we're developing since they tap out at 3.0.
• Why are we working all this out for OpenGL when our remit is Metal?

After typing all this out it seems clearer to me. But everyone else should weigh in.

[link2xt]

Dropping 6.51% of Android devices is a lot, every ~17th user will be unable to use the apps after such an update. There should at least be some fallback, maybe not supporting all the features or using more battery, but displaying the map using GL 2.0.

[louwers]

@ntadej Yes that is an option!

@link2xt Nothing is impossible but it's probably a significant effort.

[sjg-wdw]

After we're done with the modularization someone could probably go through and reimplement ES 2.0 if they wanted to.
It wouldn't be particularly easy and it might just be simpler to stick with an old branch.

3.0 support showed up in API level 18. I'd be curious to hear from developers with their minSdk set below 18.

[link2xt]

We have minSdkVersion set to 16: https://github.com/deltachat/deltachat-android/blob/343843966fbd2e0a3ee806d0c96726bea31b46bb/build.gradle#L105

[mwilsnd]

My 2 cents, at Meta most apps only support API 21+. The exception is WhatsApp which supports 16+ and does see older devices without ES 3 support like the Exynos variant Samsung S4. We plan to keep applications which must support ES 2 on the last MapLibre release while upgrading everything else, until the time comes when older holdouts decide to deprecate old devices. Devices like the S4 are going on 10 years old at this point, trying to maintain support for them is only going to limit growth and capabilities of the library.

[sjg-wdw]

Accidentally put this in the wrong spot:
I'm seeing different numbers out there. Google seems to show 6.5% of devices have 2.0. But distribution numbers suggest it's only 0.5% for API level 18 and below.

In any case, there still are devices out there.

We can kick this around a bit more, but at this point the approach would be to add a separate module to support 2.0 if that was deemed important. There are some key features in 3.0 that make this work much easier.