OpenGLES is (more or less) a stripped down version of OpenGL (which mainly removes the old legacy cruft, and any features that may hurt battery life). There are a few very minor differences here and there, but that's largely the case.
On the Pi, you are limited to GLES. However on desktop, both NVidia and ATI support OpenGL and OpenGLES. I would imagine your SDL based app is targetting an EGL context with GLES, and since SDL wraps all of the platform specific Windowing APIs, that should just work on desktop.
If you really want to know the gory details, read on...
The way you initialise OpenGL (and GLES) is to query the graphics driver for a pointer to a function. So lets take a rubbish example:
// This will typically be in gl.h
// some magic to prevent C++ name mangling, and use
// C naming conventions.
#ifdef __cplusplus
# define EXTERN extern "C"
#else
# define EXTERN extern
#endif
// declare a function pointer type that matches void glFinish()
typedef void (*GL_FINISH_PTR_TYPE)();
// now declare a function pointer that will hold the address.
// The actual pointer will be buried away within OpenGL.lib,
// or GLES2.lib (i.e. within a C file somewhere)
EXTERN GL_FINISH_PTR_TYPE glFinish;
Basically that process will be repeated for the entire GL API.
Then within some source file, we'll declare the pointer...
#include "gl.h"
// here is our function pointer, which we will set to NULL initially
GL_FINISH_PTR_TYPE glFinish = NULL;
Now the following tends to be platform specific, but on each platform we want to pull the address for those GL methods from the driver. So on windows it looks a bit like:
#ifdef _WIN32
void initGL()
{
// extract pointer for glFinish from the driver
glFinish = (GL_FINISH_PTR_TYPE)wglGetProcAddress("glFinish");
}
#endif
and on the raspberry pi, it would look like:
#ifdef RASPBERRY_PI
void initGL()
{
// extract pointer for glFinish from the driver
glFinish = (GL_FINISH_PTR_TYPE)eglGetProcAddress("glFinish");
}
#endif
So the only things that differ between the platforms are:
- The APIs needed to create the window
- The APIs needed to create the OpenGL (or GLES context)
- The function you need to call to extract the function pointers.
Handily all of the platform specific stuff is wrapped up nicely within SDL, so you really don't need to care about it. Just target SDL, and so long as you restrict yourself to the GLES API calls, it should just work on both platforms...
caveat: You may encounter minor driver differences between NVidia/ATI/Intel hardware (e.g. max supported textures size, etc), and obviously differing hardware will have differing specs for amount of RAM, etc. If your app works on the lesser hardware platform, it will usually work on the better hardware as well...
