I have a very simple question. I am now uploading an app to Google Play for the first time. The app was made in Unity and it allows OpenGLES 2 and OpenGLES 3 however it runs much better with the latter. In my APK info that I can access via Google Play Console, it says:
OpenGL ES versions: 2.0+
I just wanted to make sure that 2.0+ means all OpenGLES versions including and greater than 2.0. That means 3.0, 3.1, 3.2 etc as well. Is that correct? I really wouldn't want to release the app without OpenGLES 3 by mistake.
According to developer.android.com:
The OpenGL ES 3.0 API provides additional features and better performance than the 2.0 API and is also backward compatible.
I. e. OpenGL ES 3 is a superset of OpenGL ES 2.
So you can set the requirement as OpenGL ES 2.0+ without a doubt.
Related
What's the currently supported version of OpenGL ES in WearOS 2? Ist OpenGL ES 3.x supported, assuming the hardware can support it? I can't find any documentation for it.
According to the Play console, Wear OS devices do support GL ES 3.0. Here's a screen grab from the device page for the Huawei Watch 2 on my console:
Given that Wear OS is Android under the hood, you can usually assume that anything not obvious or documented to be different is the same. So yes, it probably is going to be whatever the hardware supports.
I have published an instant app, which can be downloaded from android marshmallow, nougat, etc. but openGL is only being rendered on android pie, the normal app works fine on all android versions, both APK's are the same actually it is an app bundle.
https://issuetracker.google.com/issues/132952558
Quoting the answer here so it helps others as well:
OpenGL ES 1.0 is only partially supported, we do not recommend you to
use this.
OpenGL ES 2.0 is fully supported for Instant Apps.
Additionally, OpenGL ES 3.0 is not supported on pre-O Instant Apps.
This was previously documented somewhere, but not anymore, so we’re
working on getting these details back in.
I have spent a few dozen man hours searching Google and asking questions on forums trying to figure out whether or not my OpenGL ES 2.0 application on Android is lagging due to errors on my end, a virus on my device, OpenGL implementation on Android, or OpenGL implementation on the Samsung Galaxy Express.
I have found nothing, if anyone wants to try answer that root issue I would greatly appreciate it, but my question is if I should revert back to OpenGL ES 1.0 and if that is what everyone else uses.
The exact same application (single spinning triangle) using the exact same timestep with the only difference being a barebones OpenGL ES 1.0 vs OpenGL ES 2.0 change causes stuttering in the 2.0 app and smooth animation in the 1.0 app.
Do other games only use 1.0? If they use 2.0 can you point me to an example that is known to cause no noticeable stuttering, that I may download and test on my device? I have downloaded the OpenGL ES 2.0 sample from Google themselves, stutters the same.
Does Samsung Galaxy Express not handle OpenGL ES 2.0 gracefully? Is there any way to get another Android device without stealing or asking random strangers, I have no money.
Thank you.
Thing is that OpenGL ( not just ES ) is a specification, the other part the implementation is not governed by anyone, well by the specification to a certain extent meaning that the implementations can differ greatly altho they shouldn't.
This is due to the fact that OpenGL uses client drivers to handle the commands and those are written by the GPU creators ( usually ). For PCs you can easily name all the prominent GPU builders, nVidia and ATI so there you can at least know what to expect.
For phones there are lots of GPU/CPU combos so more errors to be discovered due to faulty or wrong form the start designs, not just the GPU's drivers, since the phone's creator may also make changes to the system or use low speed/grad parts which will result in poor performance.
OpenGL ES 1.0 I would say is more common since 2.0, mainly because it's backwards compatible so a device that supports 2.0 will most certainly support 1.0 as well. For development you can skip the whole "build on phone" thing by making a framework and using an emulator ( OpenGL ES ) on PC and when you are done just copy over your OpenGL code into your phone app.
Since manufactures try to keep their costs low, they tend to lie about what they actually do, or support so ES 1.0 being more simple and hard-wired than 2.0 it is possible that the lag may be due to the poorly supported OpenGL.
According to the latest Android Platform Dashboards, Open GL 2.0 makes up 98.3% of devices that visited the Play Store in the last 7 days, making it the standard for game development.
I have noticed a lot of people seem to have trouble with the OpenGL ES drivers for Samsung Android devices. You should try another device with a different graphics core.
Since Ice Cream Sandwich, the Android platform itself mostly uses OpenGL ES 2.0, including major components, such as the SurfaceFlinger. It's not optional anymore. Check out this article.
Hi we're developing a live wallpaper application for android handsets, our coding team is saying that openGL 1.1 should be used instead of openGL 2.0.
http://developer.android.com/resources/dashboard/opengl.html
This shows that openGL 2.0 is supported on 90% of devices accessing the market, our coding team says that the software supports it but hardware acceleration and support would be an issue on many devices running android 2.2 and above. Anyone have any issues with openGL 2.0 and Android?
I think most devices that support OpenGL ES 2 have appropriate hardware acceleration.
A lot of the newer devices actually emulate OpenGL ES 1.1 support using
OpenGL ES 2.0 and so would need an appropriate hardware accelerated 2.0 driver.
I've never heard of an Android device that emulates opengl es 2.0 in software, not even the emulator can do so.
"OpenGL ES 2.0 is supported by most Android devices and is recommended for new applications being developed with OpenGL"
From: http://developer.android.com/guide/topics/graphics/opengl.html
You should read the sections "OpenGL Versions and Device Compatibiity" and "Choosing an OpenGL API version", and you should trust Google and not your coding team.
I need to get an idea of how many potential installs I'll be loosing if I choose to do my drawing in OpenGL instead of android's native 2D graphics APIs in android.graphics.*
The android documentation seems to imply that the OpenGL ES API is supported basically on all phones: http://developer.android.com/guide/topics/graphics/opengl.html
OpenGL ES 2.0 is supported by most Android devices
Now, does that imply that even cheap commodity devices will have OpenGL ES 2.0 support? Will the cheaper phones perhaps have software rendering, or will it always be hardware rendering?
I take it that the documentation's wording of "most android devices" means that there may indeed be some phones which are running android-8, but just don't have the hardware for OpenGL ES 2.0. But how many phones is that exactly?
Check the Device Dashboard by OpenGL ES version.