Doom Creator Says Direct3D Is Now Better Than OpenGL

arcticstoat writes "First-person shooter godfather and OpenGL stickler John Carmack has revealed that he now prefers Direct3D to OpenGL, saying that 'inertia' is the main reason why id Software has stuck by the cross-platform 3D graphics API for years. In a recent interview, the co-founder of id Software said, 'I actually think that Direct3D is a rather better API today.' He added, 'Microsoft had the courage to continue making significant incompatible changes to improve the API, while OpenGL has been held back by compatibility concerns. Direct3D handles multi-threading better, and newer versions manage state better.'"

Re:"Doom creator"?

[Tanman]

I know. He created commander keen, first, so that should have been the game they used.

The answers depend on the questions

[SplashMyBandit]

Carmack changed his mind some years ago. This report is quite late.

However, the title of the magazine is "Custom PC". It is worth keeping in mind that if the PC and Xbox are the only platforms you are targeting then DirectX is a valid choice for development technology.

Otherwise, you are better off developing in OpenGL, where you can target PCs, PS3, iPhone, iPad, Mac OS X, WebGL, industrial Unix (not all 3D apps are games, dontchaknow?). The only thing you can't do much with is the Xbox (technically possible, but deliberately closed by Microsoft).

Also, the pace of change in OpenGL has picked up tremendously with the stewardship of the Khronos group. So OpenGL is starting to have parity in features again after lagging for some time (plus, you can get those features on Windows XP for those still on it).

Because things change

[Sycraft-fu]

So back in the Doom days, there was no such thing as DirectX. OpenGL was all their was. Of course it was high end cards only, no consumer stuff.

So move on up to 1996 and the 3dfx Voodoo comes out. It couldn't support full OpenGL, but Glide was based on OpenGL and it brought real 3D to consumers. DirectX was at 3.0 at this point and had no 3D. Glide, or a subset of OpenGL with a wrapper (how Quake did it) was it.

DirectX 5 came out in mid 1997 and did have 3D, but it was somewhat basic. I mean it could support what consumer cards could do, but lacked a lot that OpenGL had. Still no real comparison.

However by 2001, DirectX 8 was out and DX was showing some real competition to OpenGL. nVidia had been doing DX and OGL as native APIs for their cards for some time, and both ran just as fast. Also now the cards had programmable vertex and pixel stages, just like the high end pro card, and in fact nVidia was selling their consumer hardware in the pro market as Quadros.

From there, DX just started pulling further and further ahead. DX10 was a major update and brought some cool new GPU features, like fully unified shaders. Support for it was not a lot on the software side since it required Vista and games have to deal with older computers, but the GPU makers loved it. OpenGL was not fast in terms of catching up.

DX11 pushes things forward again, and again OpenGL is playing catchup and doing it in a poor fashion with extensions. Not just new graphics features either, but things like support for real multi-threaded and multi-tasking rendering. The ability to treat a GPU much like a CPU and task switch on it and so on.

Then of course there's DirectCompute, part of DirectX. GPGPU integrated in to the API and the same for all vendors. Of course there is OpenCL, a similar idea, but it is not integrated as DC is in to DX.

So back when Carmack was an OpenGL fan, it was because it was the best. However it isn't anymore and as things have changed so has his opinions.

Re:DirectX

[Eponymous Coward]

Visual Studio is ok, but it's very overpriced and poorly supported by Microsoft.

My favorite IDE is IDEA from Jetbrains.

Re:Not only that

[Anonymous Coward]

[quote] ...Khronos doesn't seem to go out and engage the vendors during development and try to have OpenGL ready to meet the next gen cards. ....
[/quote]

Complete utter bullshit. The chair of the ARB OpenGL working group is the lead for GL driver development for NVIDIA. Much of the jazz for the OpenGL specifications is driven by the hardware makers. Many GL extensions that were first exposed by NVIDIA made it into GL3, and that tradition continues today.

The major stinks people have had with GL:
  1) GL3 was late and a disappointment (the disappointment is mostly related to not getting direct state access of GL objects)
  2) Direct State Access (i.e. can edit objects without binding them first) is available as an extension. As of now AMD and NVIDIA support that extension (it has other parts too, for reference that extension's name is GL_EXT_direct_state_access. I'd make a substantial bet that GL4.2 will have it in core.
  3) Few tools in comparison to Direct3D (though glDebugger is for free now)
  4) Inconsistent behavior and implementations of GL across different hardware vendors. Intel's GL sucks monkey balls, NVIDIA's lets you get away with murder and ATI makes you follow the spec with all i's dotted and t's crossed. Additionally, what is fast for one IHV is not fast for another (buffer object usage hints I am looking right at you).

There is also some truth to that GL now "follows" Direct3D, i.e GL4 came out after D3D11, etc.
Though, there are extensions in GL that completely blow the living crap out of anything you can do with Direct3D, take a look at GL_NV_shader_buffer_load. Full blown (read only) pointers in shaders (pointers point to data of buffer objects). Nothing in Direct3D compares to it.. and it is for GeForce 8/9/1xx/2xx/3xx cards! For the next generation (GeForce4xx) there is even write access (GL_NV_shader_buffer_store).

Re:DirectX

[Kevin Stevens]

Pretty telling that you couldn't actually respond with an answer.

VS makes me want to code. It makes browsing code so much easier. Debugging is so nice that I will often fire up a debugger and step through code if I have a hard time figuring out what something is doing. I have been in several situations where my entire team couldn't find a multithreaded related crash using gdb, but I have never had a bug escape me when debugging through Visual Studio. You can actually control administer your machine a lot more efficiently through VS than you can by clicking through the control panel. Its easy on the eyes, though you don't get "hardcore" points w/ coworkers for a black background with neon text. In my opinion, coding is easier, bugs get found faster, code gets written faster. Compile error? click on the error, and it will take you to the offending line. Huge convenience. And note I am talking about raw C++ here- no managed code, .net, or any other stuff.

Clearly there are drawbacks- Intellisense just stops working sometimes, for no apparent reason. The build system is different than make, and can be annoying at times, but its way easier than fighting with autotools, though CMAKE is a little nicer (though fortunately CMAKE can generate vcproj files). Integration w/ source control other than VSS is a pain- usually I just avoid that altogether and leave them unintegrated.

I have tried alternatives- I used Emacs in college exclusively, until I got sick of a million meta commands and having to write programs just to configure my IDE the way I like it (a little exaggeration there, but not much). browsing between files on large projects was too cumbersome.

I have tried Eclipse and its god awful view system, where god forbid I click the wrong place or hit the wrong button my whole screen just gets deranged. I find the Eclipse model very awkward, the plugins are buggy, and intellisense works even less frequently than VS. For Java, Eclipse is good.

I tried QTCreator, which was alright, but seemed very focused around building QT apps. I just wanted to do general dev, and the UI was too Apple-ish for me- I don't need a shiny IDE, just one that is pleasant to look at and lets me get things done.

I have not tried net beans for C++, mostly because Eclipse CDT has lead me to believe that java IDE's shoe-horned to C++ IDE's don't seem to work that well. I could give Code::Blocks another shot as well.

So seriously, what do you recommend? And what specifically do you think your recommendation does better than Visual Studio?