19
\$\begingroup\$

When the OpenGL spec is updated, they only ever add features. So in theory, the latest and greatest hardware with support for the Core and Compatibility profiles should run super old OpenGL1.1 code just fine. This has turned out to be true. I've spent 12 months learning OpenGL1.1 and have a fair grasp on it.

I had a read of a few chapters of one of those fancy new OpenGL4.2 books. Almost all of the features that I rely on have been deprecated (like Display Lists), which lets me assume that there are better ways of doing all these things.

Lets consider that 1.1 is likely to be supported, in full, by ALL modern hardware. 1.1 was released in 1992. I'm not coding the hard way just to support 20 year old PCs. :-p I think its reasonable to assume most gamers are running hardware that bottoms out at about 5-year old mid range.

I think the newer methods are designed to universally be either one of two things: better performing, or easier to code. I read somewhere that its never both though! XD

What version of OpenGL is most widely supported by ~5ish year old hardware? What version makes most sense to use, given these considerations?

Improve this question
\$\endgroup\$
0

6 Answers 6

Reset to default
20
\$\begingroup\$

Given your considerations, I then popped over to see when OpenGL specs for each version was released and also factored in some overall insight from what I've seen.

OpenGL 3, which introduced FBOs, VAOs and other things, was released in July 11, 2008, almost 5 years ago. Of course, you can't expect all cards after that date to immediately to have OpenGL 3 available.

Taking a look at the Steam Hardware Survey, 40% are DirectX 10. As OpenGL 3 required a similar graphics card, it is generally safe to assume most DirectX 10 cards can run at least OpenGL 3.

OpenGL 3 is supported on cards all way back to GeForce 8xxx series, which were pretty popular if I recall correctly. Also interesting to note is that Intel HD 2000 and 3000 Graphics (Sandy bridge) only support up to OpenGL 3, so keep that in mind if you plan to target those.

Conclusion: OpenGL 3 is a good bet (also remember that most gamers, depending on your target audience, will probably have better hardware than average).

Improve this answer
\$\endgroup\$
5
  • \$\begingroup\$ This is a great answer. Was exactly the sort of insight that I was looking for. \$\endgroup\$
    – Suds
    Mar 14, 2012 at 11:59
  • 3
    \$\begingroup\$ "Also interesting to note is that Intel HD 2000 and 3000 Graphics (Sandy bridge) only support up to OpenGL 3" Note: they only support GL 3.1 (because Intel just doesn't care). And since it's Intel, "support" should be taken with a grain of salt. Their hardware could support 3.3, but they don't expose that (because again, they don't care). I would avoid using OpenGL 3.x on Intel hardware at all. Indeed, I'd avoid doing anything shader-based on Intel hardware. \$\endgroup\$
    – Nicol Bolas
    Mar 14, 2012 at 23:28
  • \$\begingroup\$ The question then gets raised; how saturated is the market with intel hardware? Is it worth not caring about intel graphics and using OpenGL3.x anyway? Or is there enough intel graphics hardware out there to actually matter? \$\endgroup\$
    – Suds
    Mar 15, 2012 at 1:34
  • 1
    \$\begingroup\$ One problem is OSX. The latest release 10.7.x only supports OpenGL 3.2, 10.6.x only supports 3.0 (or maybe even 2.x). 10.5.x varies greatly depending on the card, 1.3, 1.5 and 2.0 are possibilities. Those systems will be forever stuck at those OpenGL versions unless the user pays money to Apple for an update. There's no video card driver updates or such for OSX that will update OpenGL. Other problems are some of the dogey embedded Intel chipsets use in netbooks. Many of them are only OpenGL 2.0 or worse. \$\endgroup\$
    – David C. Bishop
    Mar 19, 2012 at 6:36
  • \$\begingroup\$ And then you have the 3DS, which is still rocking OpenGL 1.1... \$\endgroup\$
    – kirbyfan64sos
    Aug 30, 2016 at 1:14
8
\$\begingroup\$

I'd start here: http://store.steampowered.com/hwsurvey

I wouldn't target a time period so much as a percentage of users, for instance, if you target 4cpus, you'll only hit 45% of users, but if you work to 2, you'll get close to 90%

Improve this answer
\$\endgroup\$
3
  • 1
    \$\begingroup\$ Where did you see OpenGL? I only see DirectX (which is something interesting to note if you plan only to target Windows). \$\endgroup\$
    – DMan
    Mar 14, 2012 at 3:51
  • \$\begingroup\$ I'm guessing you do the legwork based on the graphics card breakdown \$\endgroup\$
    – Jimmy
    Mar 14, 2012 at 4:09
  • \$\begingroup\$ Yeah - I didn't see anything about OpenGL - but you can get it from the card models, or indeed, I believe there would be a fair amount of correlation between DirectX versions and OpenGL. \$\endgroup\$
    – salmonmoose
    Mar 14, 2012 at 12:37
3
\$\begingroup\$

The answer depends on whether or not you need to or want to run on Intel graphics released within the timeframe you mentioned.

If you do, then limit yourself to OpenGL 2.1 (or even 1.5), if you don't then 3.x seems reasonable.

Yes, older versions of OpenGL do still run, and yes, from one perspective they can seem simpler. Where things go bent out of shape is when you try to do things (and you will) that they don't support too easily. OpenGL 1.1 isn't just the hard way - it's often the impossible way if you want to achieve certain results.

Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ It occurs to me that I should add an example of why 1.1 is often impossible. One such that can be easily related to 1.1 functionality is multiple blend passes. Because you have no FBOs and you're mostly limited to 8 bits per component textures, you'll find that as blend passes pile up you'll start losing precision. Use 3/4/5 passes and the end result will start looking like (or worse than) 16-bit or 8-bit graphics. Yet multiple passes are often required to simulate higher level effects (basic multitexturing would be one that we're all familiar with) with a 1.1 feature set. \$\endgroup\$
    – Maximus Minimus
    Mar 15, 2012 at 2:25
  • \$\begingroup\$ Even Intel HD graphics (Sandy/Ivy Bridge) only supports OpenGL 3.1, and that's a year old. It comes down to whether you want to support cheap (or low-power) laptops. \$\endgroup\$
    – Steve Howard
    Mar 26, 2012 at 5:11
  • 2
    \$\begingroup\$ @SteveHoward: Intel HD Graphics can support OpenGL 4. source \$\endgroup\$
    – Janus Troelsen
    Feb 22, 2013 at 14:02
  • \$\begingroup\$ That article's from about 3 months after I posted my comment. \$\endgroup\$
    – Steve Howard
    Feb 24, 2013 at 10:51
1
\$\begingroup\$

Firstly OpenGL 1.1 stuff like Display Lists will still work in a new context provided you have the compatibility profile (which is generally the case). The only problem is if you expect to port to OpenGL ES, one of the console specific graphic library (they are generally stripped down OpenGL similar to OpenGL ES) or even WebGL (which would require quite a bit of reworking anyway).

Personally I would recommend using vertex/fragment shaders and VBO's. They have been around for quite a long time now and offer great performance improvements. You could probably even provide a simple fall back if you wrap the functions in a class.

You may also be able to emulate things like Vertex Array Objects.

Improve this answer
\$\endgroup\$
0
\$\begingroup\$

With 5-ish year old hardware, some people are still using XP. And that means that you can't even code with DirectX 10 or OpenGL 3. And OpenGL 3 has a lot of features that you'd really benefit from, like framebuffers and such. Honestly, I'd bump up your system requirements just a bit so that you can include those features.

Improve this answer
\$\endgroup\$
1
  • 8
    \$\begingroup\$ -1: "With 5-ish year old hardware, some people are still using XP. And that means that you can't even code with DirectX 10 or OpenGL 3." Not true. OpenGL 3.x runs just fine in XP. It's only D3D10 that's restricted from XP, because of API/driver reasons. It has nothing to do with the hardware. \$\endgroup\$
    – Nicol Bolas
    Mar 15, 2012 at 8:26
0
\$\begingroup\$

It is common for 3d software to have code paths for both a "baseline" graphics api version and a "latest and greatest" api version.

Common baseline graphics versions are D3D9 and OpenGL 2.1 / GLSL 120 .. Which are both notably missing geometry shaders because old hardware does not support them.

Another baseline option is ANGLE, which is GLES 2.0 plus EGL that runs on D3D9, desktop OpenGL, and mobile GLES 2.0. It is the back end for Google chrome and webgl in chrome and Firefox.

http://code.google.com/p/angleproject/

As for the "latest and greatest" version you choose, that is more challenging. The more recent api and hardware you target, the better looking features you can support - but only on the latest and greatest hardware.

Improve this answer
\$\endgroup\$

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