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.
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.
Does anybody know what the deal is with declining support for the WebGL extension OES_texture_float on Android over the years?
https://webglstats.com/webgl/extension/OES_texture_float?platforms=000000000010000400
Is this a data collection error of some sort, or is the support really declining?
If you take Android out of the filter then `OES_texture_float is supported on basically 100% of the other mainstream mobile and desktop platforms:
https://webglstats.com/webgl/extension/OES_texture_float?platforms=000036048004003200
declining support for the WebGL extension OES_texture_float on Android over the years?
There are a large numbers of OpenGL ES 2.0 parts shipping which simply don't support floating point texturing (all of the Mali-4xx series, for example).
It's a core feature in OpenGL ES 3.x, so I suspect a lot of mobile vendors don't expose the extensions and just expect people to switch to a newer API which has all of the new features as part of the core spec rather than supporting them piece-meal. Given WebGL 2 is now published, this seems a sensible approach to me as it guarantees some level of cross-platform portability ...
We've been trying to get a port of mkxp to android. It uses SDL 2 and opengl es 2. The game works perfectly on Mali GPUs, but doesn't work as expected on PowerVR and is completely broken on Adreno. Is there any work around? Is it, for example, possible to completely bypass hardware acceleration and use software rendering, because some parts (eg the backgrounds etc.) work on all devices. I'm a beginner, so please don't mind any foolish question :)
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.
I tested my app on some Android 2.1 and 2.2 devices. So I think that they support OpenGL ES 1.1
But on some devices I had problems whit my app. I get an unsupported operation exception means the device does not support the GL 11 interface. Is this a hardware problem? Are there some possibilities to avoid this problem?
Thanks,
Mijat
I think that the exception I get is not useful. Because I pick a peace of code from the net, and this one checks the extension I temporally need with all extension from the interface GL 11.
And if there is no agreement, the code throws a exception.
The Problem case is, that I have an app and I tried in on the HTC Desire and some model of LG. It works great, but on a third device which works on Android 2.2 I get this exception.
Means OpenGL ES GL11 isn’t covered.
From http://developer.android.com/guide/topics/graphics/opengl.html :
Finally, note that though Android does include some basic support for OpenGL ES 1.1, the support is not complete, and should not be relied upon at this time.
Pretty much answers the question.