Take the 2-minute tour ×
Game Development Stack Exchange is a question and answer site for professional and independent game developers. It's 100% free, no registration required.

I'm not entirely familiar with the feature set introduced by DX10/11 class hardware. I'm vaguely familiar with the new stages added to the programmable graphics pipeline, such as the geometry shader, the compute shader, and the new tessellation stages. I don't see how any of these make much of a difference for a 2D game though.

Is there any compelling reason to make the switch to DX10/11 (or the OpenGL equivalents) for a 2D game, or would it be wiser to stick with DX9 considering that that a significant share of the market still runs on older technologies (e.g. the February 2012 Steam surveys lists around 17% of users as still using Windows XP)?

share|improve this question
add comment

3 Answers 3

up vote 5 down vote accepted

It depends on what you're doing. If you're using Direct3D, the only reason to switch is to gain access to hardware features that you can't get otherwise.

For a 2D game, it is theoretically possible that certain features might interest you. For example, OpenCL or DirectCompute. Civilization V gets some use out of DirectCompute for decompressing textures. This dramatically reduces load time, because it only has to load compressed data. And 2D games often have a lot of images. If load time is an issue, this might help.

OpneCL should be available on all GeForce 8xxx hardware and above. On ATI, it's available on HD 4xxx and better hardware.

I'd say the biggest feature you might use in DX11 is the ability to more arbitrarily read and write images in shaders. That could be useful for certain specialized effects. I can't think of any right now... which should tell you how likely this is to be important.

In general, I would say that if you're using D3D, you probably won't gain much. And if you don't already understand what the new features are and want to use them in your game, you almost certainly won't gain much. Most of them are going to be more complex.

OpenGL is different for one major reason. OpenGL 2.1 (the more-or-less equivalent to D3D9) sucks as an API. OpenGL 3.3 (plus some more recent extensions that run on 3.3 hardware) improves the API a lot. Explicit attribute location, separation of shader programs, everything in shading language pack 420, and so on.

Some of these work well enough in extension form against 2.1. Some of them... don't. I'm still not sure if it's OK to use explicit attribute locations with attribute declarations (before the current in syntax). Shading language pack 420 specifically says that it doesn't work with GLSL versions before 1.30 (aka: OpenGL 3.0).

That's not to say that GL 2.1 is unusable. It's certainly functional and serviceable, just not enjoyable. Though some drivers that you'll find that implement it aren't serviceable. ATI's DX9 hardware is no longer being supported, so those drivers are really buggy. And Intel never cared about OpenGL, so using shaders on their hardware is pot-luck.

But personally, if your intended user-base allows it, I would push to GL 3.3 if you're using OpenGL. If not, you'll just have to deal with the 2.1 issues.

share|improve this answer
add comment

There's a few things I think you should consider:

  • If you have a well tested D3D9 engine, it's probably not worth porting to D3D11, if you won't make use of the new features. When starting from scratch D3D11 is much more tempting.

  • How soon is your game's release date going to be? XP will be out of support in just over two years, and if you look at the historical data that XP install base is dropping quite quickly (~1% / month on Steam).

  • Consider what proportion of the 17% of XP users would have a PC that meets the minimum spec for your game under D3D9. The higher that is the more worthwhile it is supporting them.

  • DX10 is mostly pointless to use for new development. DX11 runs on the same operating systems and hardware (via feature levels).

  • DX11 supports a software renderer (WARP) as a fallback device, which can be quick enough to run a game with low GPU requirements.

  • Native DX9 supports more features than D3D11 does when it's using any of the D3D9 feature levels. Thankfully DX9 hardware in DX10 capable PCs is rare.

  • DX10/11 hardware has much less varied capabilities so, if you make DX9 hardware use WARP, you don't need to worry about awkward limitations with things like non-power-of-two textures or awkward texel-pixel mapping.

  • If your game is going to be hardware intensive DX11 has a few extra tricks available to boost performance. Multi-threading the draw code for example.

share|improve this answer
    
I'm a bit confused about the feature levels. If I develop using DX11 but targeting a DX9 feature level, I understand that it will run on DX9 hardware. But will it still require the DX11 runtime i.e. will it run on Windows XP? –  David Gouveia Mar 18 '12 at 20:19
    
DX11 doesn't work on XP at all. What the feature levels do is let you use the DX11 API with older hardware. Check out msdn.microsoft.com/en-us/library/ff476876%28v=vs.85%29.aspx for details of what each feature level lets you do. –  Adam Mar 19 '12 at 0:41
add comment

Geometry shaders alone are a reason to use D3D10/11, if you plan on having a large number of particles or sprites.

DirectCompute can also be used for some nice speed benefits.

Personally, simply having the far cleaner and nicer API of D3D10/11 is enough reason to never touch D3D9 or OpenGL again for any modern-Windows-only projects. Realistically, though, the need to target mobile devices with GL|ES and the still sizable WinXP crowd necessitates avoiding D3D10/11 and sticking to either D3D9 or OpenGL.

Note that going the OpenGL route lets you get geometry shaders, OpenCL, and other newer hardware features even on WinXP.

share|improve this answer
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.