4
\$\begingroup\$

I have an animated 3D iPhone game that I first wrote using OpenGL ES 1.1 in late 2009.

After many updates to the rest of the game, the OpenGL ES 1.1 code still runs fine under iOS 6, but I'm wondering about benefits to 2.0 that I'm missing out on, and whether it is worth converting to. I don't care about backwards compatibility with devices unable to support 1.1.

I've read this post and this post on the sister site, but some information there is no longer applicable, and I would like a perspective specifically from a gaming programmer's point of view about whether it's worth updating, rather than which I should use if I were doing it from scratch.

Thanks for your help.

[Edited to answer comments below]

This is the project. I don't need shaders, textures, or anything ES 1.1 doesn't do in some fasion (at least for a while), but would be tempted to upgrade if for example 2.0 just does it much better, or is much faster, or does something that's just so useful and/or awesome that it would be criminal not to take advantage of it, or 1.1 has some awful bug on a device that I haven't had a chance to test on.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Do you need shaders? \$\endgroup\$
    – luiscubal
    Commented Jan 14, 2013 at 15:33
  • \$\begingroup\$ I think this question is very borderline "Which technology to use" by the way (see the FAQ about those). Since you don't list any requirements for your project and essentially just want to know if you should use X or not. \$\endgroup\$
    – House
    Commented Jan 14, 2013 at 15:42

4 Answers 4

Reset to default
4
\$\begingroup\$

If it's worth it or not depends entirely on your needs, the goal of the project and the resources available for the project vs what resources it will take to upgrade.

However, simply based on what you've described, I would see no reason to upgrade. You've said the game you wrote still runs fine, so it sounds like there's nothing to fix. If there's no problems that will be overcome by switching to 2.0, it's not worth it. You'd just be generating work for yourself at that point.

If you were to start a new project, you might as well use 2.0, if that project also doesn't have the requirement of supporting older devices.

\$\endgroup\$
2
\$\begingroup\$

While ES 1.x is supported by new devices, the support is actually implemented on top of the shader hardware. This means that writing directly to ES 2.0 (or 3.0) should give you a bit of a performance edge over 1.x, as well as the obvious flexibility shaders give you.

If the ES 1.x implementation has bugs, they may be harder to figure out since everything goes through a couple of layers. This is less of a reason to go with ES 2+, but a thing to consider nevertheless.

Third upside is getting on with the times; what you learn now by moving to ES 2+ will help you in the future.

Downsides include potentially more complex code, having to figure out how to implement the same things with shaders, potential shader compatibility issues between devices (all the devices have their own compilers, after all), and potentially no obvious visible change for your customers.

\$\endgroup\$
2
  • 2
    \$\begingroup\$ For what it's worth, when I was working on major iOS games, I did profiling which indicated that on some devices (iPhone 3GS and iPad1, most notably), an equivalent OpenGL ES2 implementation rendering a full scene actually ran consistently slower than an OpenGL ES1 implementation (slower by several milliseconds). On later hardware, there seemed to be no real difference between ES1 and equivalent ES2. \$\endgroup\$
    – Trevor Powell
    Commented Jan 14, 2013 at 19:54
  • \$\begingroup\$ The performance gains are probably not worth it given that if it ran on ogles 1.x hardware they probably don't need to optimize it for the newer hardware. \$\endgroup\$
    – Tetrad
    Commented Jan 14, 2013 at 21:56
2
\$\begingroup\$

The pragmatic perspective:

The benefit of upgrading from OpenGL ES 1.1 to OpenGL ES 2.0 is that you get to use OpenGL ES 2.0 features which aren't available in OpenGL ES 1.1 (most notably, shaders and framebuffer objects).

If you don't plan to use those features (as you say in your question), then there are no benefits to modifying your program to render using OpenGL ES 2.0 rather than 1.1. In fact, it limits the number of devices which will be able to run your program -- devices older than the iPhone 3GS can't run OpenGL ES 2.0 code at all. Thus shrinking your market for no gain at all.

Additionally, (and this is probably obvious, but is still worth pointing out explicitly) if you spend your time upgrading your existing program to run using OpenGL ES 2.0 (so that it can fail to work for some users and provide no benefit to the rest), then that time is time you won't be spending to write your next game. Which probably would be an activity of more benefit both to yourself, and to everyone who enjoys your games.

\$\endgroup\$
1
\$\begingroup\$

The most important reason is of course the main difference: fixed vs programmable rendering pipeline. Shaders are more flexible, allow creation of more sophisticated faster and with more performance, and you can expect more and more support in upcoming iOS devices.

Besides, 2.0 is already outdated, with 3.0 spec probably being implemented by various manufacturers right now. And since 3.0 will be compatible with Desktop OpenGL, it will further simplify creation of cross-platform programs. Transition from 2.0 to 3.0 will be certainly easier than from 1.1.

\$\endgroup\$

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .