learning OpenGL ES 2.0 under regular OpenGL - compilation

Question

I am learning OpenGL with an aim to build OpenGL ES application for Android / iPhone.

Since I learn it from the beginning, I would prefer to learn the new specification, without touching the old stuff (glBegin etc.). Unfortunately, when I pass some tutorial and implement stuff, it turns out that the examples are incompatible with ES 2.0. For example, after those excellent tutorials I know how to implement lights, what works on my PC, but would not work on a mobile (gl_LightSource is not supported in the latter).

What I would like to do, is to develop the code on my PC, and restrict the API to the commands that are supported under OpenGL ES (like, throw error on glLight). Is that possible?

Answer 1

As stated in the Mali GPU OpenGL ES Application Development Guide:

OpenGL ES 1.1 and OpenGL ES 2.0 are subsets of the full OpenGL standard. When using the OpenGL ES API, there are limitations that you must be aware of when developing your applications.

For example, the following OpenGL functionality is not present in either OpenGL ES 1.1 or OpenGL ES 2.0:

1. There is no support for glBegin or glEnd. Use vertex arrays and vertex buffer objects instead.

2. The only supported rasterization primitives are points, lines and triangles. Quads are not supported.

3. There is no polynomial function evaluation stage.

4. You cannot send blocks of fragments directly to individual fragment operations.

5. There is no support for display lists.

In addition, the following OpenGL functionality is not present in OpenGL ES 2.0:

1. There is no support for the fixed-function graphics pipeline. You must use your own vertex and fragment shader programs.

2. There is no support for viewing transforms such as glFrustumf. You must compute your own transformation matrix, pass it to the vertex shader as a uniform variable, and perform the matrix multiplication in the shader.

3. There is no support for specialized functions such as glVertexPointer and glNormalPointer. Use glVertexAttribPointer instead.

You can always refer to the OpenGL ES specification and see if a function / feature is supported.

Answer 2

Assuming you are using Windows for development, then you can restrict the API to just OpenGL ES 2.0 by using Google ANGLE. ANGLE is basically wrapping DirectX, but you use it through a fully standard compliant OpenGL ES 2.0 interface.

If you have an AMD Radeon GPU, you have another option: the AMD OpenGL ES SDK also provides a fully compliant 2.0 interface.

In both cases, if you accidentally use non OpenGL ES 2.0 features, the code will just not compile or fail at runtime in case of unsupported combinations of parameters. Same goes for shaders, the glCompileShader call will fail.

Answer 3

There is a good set of lessons available for OpenGL ES 2.0 over at http://www.learnopengles.com/. For developing on PC you can try using an emulator; many different GPU vendors provide their own emulators that translate the calls to desktop GL. However, the best way to be sure that your code works as expected is to run it on the actual device.

EDIT: A new emulator for Android has support for OpenGL ES 2.0: http://android-developers.blogspot.ca/2012/04/faster-emulator-with-better-hardware.html

Answer 4

IF you want to learn OpenGL ES 2 and make sure you are only using calls and techniques compatible with OpenGL ES 2, consider learning WebGL.

WebGL is almost identical to OpenGL ES 2. You get the advantage of a javasript console (with firebug or chrome's built-in developer tools) and in some environments (chrome on windows I think?) you get VERY helpful error messages whenever you do something wrong. Add to that you automatically have access to up to 4 implementations of WebGL to test with (firefox, chrome, safari, opera) and you have a pretty good set of tools for testing your OpengGL.

This is essentially how I have been able to learn OpenGL ES 2.