Gamasutra: The Art & Business of Making Gamesspacer
View All     RSS
July 22, 2014
arrowPress Releases
July 22, 2014
PR Newswire
View All
View All     Submit Event





If you enjoy reading this site, you might also want to check out these UBM Tech sites:


 
Why You Should Use OpenGL And Not DirectX
by David Rosen on 01/08/10 07:48:00 am   Expert Blogs   Featured Blogs

The following blog post, unless otherwise noted, was written by a member of Gamasutra’s community.
The thoughts and opinions expressed are those of the writer and not Gamasutra or its parent company.

 

Often, when we meet other game developers and say that we use OpenGL for our game Overgrowth, we're met with stares of disbelief -- why would anyone use OpenGL? DirectX is the future. When we tell graphics card representatives that we use OpenGL, the temperature of the room drops by ten degrees.

This baffles us. It's common geek wisdom that standards-based websites, for instance, trounce Silverlight, Flash, or ActiveX. Cross-platform development is laudable and smart. No self-respecting geek enjoys dealing with closed-standard Word documents or Exchange servers. What kind of bizarro world is this where engineers are not only going crazy over Microsoft's latest proprietary API, but actively denouncing its open-standard competitor?

Before we dive into the story of why we support OpenGL, let's start with a bit of history:

What is OpenGL?

OpenGL

In 1982, Silicon Graphics started selling high-performance graphics terminals using a proprietary API called Iris GL (GL is short for "graphics library"). Over the years, Iris GL grew bloated and hard to maintain, until Silicon Graphics took a radical new step: they completely refactored Iris GL and made it an open standard. Their competitors could use the new Open Graphics Library (OpenGL), but in return, they had to help maintain it and keep it up to date.

Today, OpenGL is managed by the Khronos Group -- a non-profit organization with representatives from many companies that are interested in maintaining high-quality media APIs. At a lower level, it's managed by the OpenGL Architecture Review Board (ARB). OpenGL is supported on every gaming platform, including Mac, Windows, Linux, PS3 (as a GCM wrapper), Wii, iPhone, PSP, and DS. Well, every gaming platform except for the XBox -- which brings us to our next topic:

What is DirectX?

Ever since MS-DOS, Microsoft has understood that games play an important role in users' choice of operating systems. For this reason, in 1995, they created a proprietary set of libraries in order to encourage exclusive games for their new Windows 95 operating system. These libraries included Direct3D, DirectInput and DirectSound, and the entire collection came to be known as DirectX. When Microsoft entered the gaming market in 2001, it introduced the DirectX Box, or XBox for short. The XBox was a loss leader (losing over 4 billion dollars), intended to set the stage to dominate the games market in the next generation.

Looking at the games scene now, it's clear that this strategy is succeeding. Most major PC games now use DirectX, and run on both Windows and XBox 360. With few exceptions, they don't work on competing platforms, such as Playstation, Mac OS, and Wii. These are significant markets to leave out, bringing us to the big question:

Why does everyone use DirectX?

Everyone uses DirectX because API choice in game development is a positive feedback loop, and it was shifted in favor of DirectX in 2005.

It's a positive feedback loop because whenever one API becomes more popular, it keeps becoming more and more popular due to network effects. The most important network effects are as follows: the more popular API gets better support from graphics card vendors, and graphics programmers are more likely to already know how to use it.

API use was shifted in favor of DirectX by Microsoft's two-pronged DirectX campaign around the launch of XBox 360 and Windows Vista, including the spread of FUD (fear, uncertainty and doubt) about the future of OpenGL, and wild exaggeration of the merits of DirectX. Ever since then, the network effects have amplified this discrepency until OpenGL has almost disappeared entirely from mainstream PC gaming.

1. Network effects and vicious cycles

On Windows, it's a fact that the DirectX graphics drivers are better maintained than the OpenGL graphics drivers. This is caused by the vicious cycle of vendor support. As game developers are driven from OpenGL to DirectX by other factors, the graphics card manufacturers (vendors) get less bug reports for their OpenGL drivers, extensions and documentation. This results in shakier OpenGL drivers, leading even more game developers to switch from OpenGL to DirectX. The cycle repeats.

Similarly, it's a fact that more gaming graphics programmers know how to use DirectX than OpenGL, so it's cheaper (less training required) to make a game using DirectX than OpenGL. This is the result of another vicious cycle: as more game projects use DirectX, more programmers have to learn how to use it. As more programmers learn to use it, it becomes cheaper to for game projects to use DirectX than to use OpenGL.

2. FUD about OpenGL and Vista

Microsoft initiated a fear, uncertainty, and doubt (FUD) campaign against OpenGL around the release of Windows Vista. In 2003, Microsoft left the OpenGL Architecture Review Board -- showing that they no longer had any interest in the future of OpenGL. Then in 2005, they gave presentations at SIGGRAPH (special interest group for graphics) and WinHEC (Windows Hardware Engineering Conference) giving the impression that Windows Vista would remove support for OpenGL except to maintain back-compatibility with XP applications. This version of OpenGL would be layered on top of DirectX as shown here, (from the HEC presentation) causing a dramatic performance hit. This campaign led to panic in the OpenGL community, leading many professional graphics programmers to switch to DirectX.

When Vista was released, it backpedaled on its OpenGL claims, allowing vendors to create fast installable client drivers (ICDs) that restore native OpenGL support. The OpenGL board sent out newsletters proving that OpenGL is still a first-class citizen, and that OpenGL performance on Vista was still at least as fast as Direct3D. Unfortunately for OpenGL, the damage had already been done -- public confidence in OpenGL was badly shaken.

3. Misleading marketing campaigns

The launch strategies for Windows Vista and Windows 7 were both accompanied with an immense marketing push by Microsoft for DirectX, in which they showed 'before' and 'after' screenshots of the different DirectX versions. Many gamers now think that switching from DirectX 9 to DirectX 10 magically transforms graphics from stupidly dark to normal (as in the comparison above), or from Halo 1 to Crysis. Game journalists proved that there was no difference between Crysis DX9 and DX10, and that its "DX10" features worked fine with DX9 by tweaking a config file. However, despite its obvious inaccuracy, the marketing has convinced many gamers that DirectX updates are the only way to access the latest graphics features.

While many games participate in Microsoft's marketing charade, more savvy graphics programmers like John Carmack refuse to be swept up in it. He put it this way, "Personally, I wouldn’t jump at something like DX10 right now. I would let things settle out a little bit and wait until there’s a really strong need for it."

So why do we use OpenGL?

Given that OpenGL is has less vendor support, is no longer used in games, is being actively attacked by Microsoft, and has no marketing momentum, why should we still use it? Wouldn't it be more profitable to ditch it and use DirectX like everyone else? No, because in reality, OpenGL is more powerful than DirectX, supports more platforms, and is essential for the future of games.

1. OpenGL is more powerful than DirectX

It's common knowledge that OpenGL has faster draw calls than DirectX (see NVIDIA presentations like this one if you don't want to take my word for it), and it has first access to new GPU features via vendor extensions. OpenGL gives you direct access to all new graphics features on all platforms, while DirectX only provides occasional snapshots of them on their newest versions of Windows. The tesselation technology that Microsoft is heavily promoting for DirectX 11 has been an OpenGL extension for three years. It has even been possible for years before that, using fast instancing and vertex-texture-fetch. I don't know what new technologies will be exposed in the next couple years, I know they will be available first in OpenGL.

Microsoft has worked hard on DirectX 10 and 11, and they're now about as fast as OpenGL, and support almost as many features. However, there's one big problem: they don't work on Windows XP! Half of PC gamers still use XP, so using DirectX 10 or 11 is not really a viable option. If you really care about having the best possible graphics, and delivering them to as many gamers as possible, there's no choice but OpenGL.

2. OpenGL is cross-platform

More than half of our Lugaru users use Mac or Linux (as shown in this blog post), and we wouldn't be surprised if the same will be true of our new game Overgrowth. When we talk to major game developers, we hear that supporting Mac and Linux is a waste of time. However, I've never seen any evidence for this claim. Blizzard always releases Mac versions of their games simultaneously, and they're one of the most successful game companies in the world! If they're doing something in a different way from everyone else, then their way is probably right.

As John Carmack said when asked if Rage was a DirectX game, "It’s still OpenGL, although we obviously use a D3D-ish API [on the Xbox 360], and CG on the PS3. It’s interesting how little of the technology cares what API you’re using and what generation of the technology you’re on. You’ve got a small handful of files that care about what API they’re on, and millions of lines of code that are agnostic to the platform that they’re on." If you can hit every platform using OpenGL, why shoot yourself in the foot by relying on DirectX?

Even if all you care about is Windows, let me remind you again that half of Windows users still use Windows XP, and will be unable to play your game if you use the latest versions of DirectX. The only way to deliver the latest graphics to Windows XP gamers (the single biggest desktop gaming platform) is through OpenGL.

3. OpenGL is better for the future of games

OpenGL is a non-profit open standard created to allow users on any platform to experience the highest quality graphics that their hardware can provide. Its use is being crushed by a monopolistic attack from a monolithic corporate giant trying to dominate an industry that is too young to protect itself. As Direct3D becomes the only gaming graphics API supported on Windows, Microsoft is gaining a stranglehold on PC gaming.

We need competition and freedom to drive down prices and drive up quality. A Microsoft monopoly on gaming would be very bad for both gamers and game developers.

Can OpenGL recover?

Back in 1997, the situation was similar to how it is now. Microsoft was running a massive marketing campaign for Direct3D, and soon everyone "just knew" that it was faster and better than OpenGL. This started to change when Chris Hecker published his open letter denouncing DirectX. Soon after that, John Carmack posted his famous OpenGL rant, and put his money where his mouth was by implementing all of Id Software's games in OpenGL, proving once and for all that DirectX was unnecessary for high-end 3D gaming.

This lesson appears to have been forgotten over the last few years. Most game developers have fallen under the spell of DirectX marketing, or into the whirlpool of vicious cycles and network advantages. It's time to throw off the veil of advertisements and buzzwords, and see what's really happening. If you use DirectX, you have to choose between using the weak, bloated DirectX 9 or sacrificing most of your user-base to use DirectX 10 or 11.

On the other hand, if you use OpenGL, you get faster and more powerful graphics features than DirectX 11, and you get them on all versions of Windows, Mac and Linux, as well as the PS3, Wii, PSP, DS, and iPhone. You also get these features in the rapidly-developing WebGL standard, which may become the foundation for the next generation of browser games.

If you're a game developer, all I ask is that you do the research and compare the figures, and decide if OpenGL is a better choice. Some programmers prefer the style of the DirectX 11 API to OpenGL, but you're going to be wrapping these low-level APIs in an abstraction layer anyway, so that shouldn't be a deciding factor. If there's anything about OpenGL that you don't like, then just ask the ARB to change it -- they exist to serve you!

If you're a gamer who uses Windows XP, Mac, or Linux, I hope you can see that DirectX only exists in order to keep new games from reaching your platform, and the only way you can fight back is to support games that use OpenGL.

Follow us here!
Facebook iconModDB iconSteam iconTwitter iconYouTube icon


Related Jobs

FitGoFun
FitGoFun — Mountain View, California, United States
[07.22.14]

Unity 3D Programmer
Activision
Activision — Seattle, Washington, United States
[07.22.14]

Software Engineer - Activision Seattle
Treyarch / Activision
Treyarch / Activision — Santa Monica, California, United States
[07.22.14]

Senior Environment Concept Artist - Treyarch (temporary)
Vicarious Visions / Activision
Vicarious Visions / Activision — Albany, New York, United States
[07.22.14]

Software Engineer-Vicarious Visions






Comments


Bart Stewart
profile image
While I'm enjoying reading about the development of Overgrowth (even if that information could be considered a form of marketing), and sincerely hope it does well, I can't help but be reminded by this entire blog entry of the old DEC vs. IBM arguments.



More than once in my commercial career I have heard rationalizations piled on justifications for buying DEC, but the real reason why some people evangelized for DEC machines always seemed to come down to one thing: DEC wasn't IBM. IBM was big; IBM's marketing department was effective; IBM was "a monolithic corporate giant trying to dominate an industry"; therefore IBM was evil and their competitors' products were (somehow) better and should be purchased even if they did less.



A few years later, this morality-driven product boosterism morphed into the "open" versus "proprietary" fight. Without regard for actual usability facts, the case of the proponents of "open" whatevers (machine architectures, operating systems, data transfer protocols, etc.), as with DEC vs. IBM, boiled down to a religious doctrine that "proprietary" assets, being owned by some Big Corporation, were Morally Bad and thus should be disdained (regardless of actual capability) in favor of "open" products... which always seemed to wind up under the control of some cabal of members of second-tier Big Corporations, but never mind that.



Most of the time this "open" versus "proprietary" argument was simply a veneer for an anti-Microsoft fetish. One generation's "anybody but IBM" had become the next generation's "anybody but Microsoft." But it was still the same moralistic "this product is better because it wasn't made by the industry leader" non sequitur. (If "open" really matters to those who claim it does, why aren't they equally aggressive in criticizing Apple and its highly proprietary products? Answer: Because Apple's not Microsoft.)



The "open" vs. "proprietary" rationalizations for non-Microsoft products have mostly faded, other than the Linux and Firefox propagandists. But it looks like there's still a little life in the old "smaller = not-evil" belief in the form of OpenGL versus DirectX.



I suppose I'm required to mention here that I don't work for Microsoft and have no vested interest in promoting their stuff. I'm just not interested in the argument that some product gains value because it's not made by the industry leader. Value derives from features. Period.



To the extent that this blog entry focuses on a factual comparison of features between DirectX and OpenGL, I enthusiastically support that analysis. My problem with it is that IMO it is being undercut severely by the "open" versus "proprietary" and "monolithic corporate giant" editorializing, which suggests that this comparison is merely another incarnation of the old "anybody but the industry leader" nonsense and all the arguments are simply rationalizations to try to prop up the predetermined moral conclusion.



I don't want this critique to come across as sounding personally harsh; that's absolutely not my intent. In fact, my comments are intended to help the author strengthen his argument. If OpenGL is really better for developers, then all that's necessary is to lay out the facts; if they're strong enough, they will speak for themselves.



They could do so more effectively, I believe, were they not wrapped in the language of the old "big = bad" moral premise.

Nathan Mates
profile image
"If you're a gamer who uses Windows XP, Mac, or Linux, I hope you can see that DirectX only exists in order to keep new games from reaching your platform"



As an XP user, who's bought a whole bunch of new games the past few months (most notably Borderlands & Torchlight), I disagree with the inclusion of XP in the above list. Any developer can, right now, go download the DirectX SDK, compile against DirectX 9.0c (which is an *option*; DX10/11 is not a requirement), and compile something that'll work on XP.



If you want to write something that is going to run on the vast majority of boxes out there, DX9 is still the way to go. Heck, Torchlight has a "netbook mode" checkbox in its option screens -- the developers explicitly said "yes, we know a lot of you don't have systems with great graphics cards. We'll still work on that." Combine that with Steam hardware stats that say that DX9 is still the majority of their users, it's MS (and the HW maker's) problem to try and push people to post-DX9. They'd *love* to move more developers to post-DX9, but the problem is that DX9 is good enough for most.



Yes, if you're going to write for Mac/Unix (as a FreeBSD user at home, I resent the implication that Linux gets all the attention, when it is one of many unix-likes available), then OpenGL is the way to go. But, are they the best use of your time and efforts? Xbox 360 is a *huge* part of the market, and uses a cousin of DX9. Not OpenGL. If you want the most target audience for your buck, then using DX9 will get you X360 and Win2000-Win7.



Remember this: "worse is better." Something that works well enough on the vast majority of boxes is going to take over the market from something that is probably superior, but has its own gotchas -- driver support, coding for each graphics card's extensions, etc. Yes, it pisses a lot of people off that x86 has won the laptop/desktop CPU wars, as it's worse in many ways than RISC. But, merely pointing out that "X is better for technical reasons A,B,C,D" is not going to convince people in the long term. Sorry.

Rob Jones
profile image
I should probably take the time to form a decent rebuttal to this article, however for now I'll stick with the following.



I was an OpenGL programmer for 8 years, the last year or two of that time was spent waiting for the ARB to do something decent with the API before I finally gave up and moved across to D3D10 then D3D11 where I am now.



On the power aspect, yes for small batches of draws on XP there was/is a problem. This was the whole reason behind the instancing system being introduced to sidestep the design issue of jumping into the kernel on every draw call. As I recall Vista fixed that problem for DX9 and DX10 and 11 don't have that problem.



As for the newest GPU features, well last I checked there are no extensions out for D3D11 features and it was missing a large chunk of D3D10 and 10.1 features. Those which did exist quickly came only for NV as AMD was slow to adopt them and get their implimentation up to task. The tessellation extension which was linked to didn't become public until sometime last year and is only 1/3 (at most) of the tessellation supported in D3D11, so to claim that it is the same is very dishonest and incorrect.



My biggest amusement however came from this line, in fact I got a strange look in the office when I burst out laughing;

"If there's anything about OpenGL that you don't like, then just ask the ARB to change it -- they exist to serve you!"



Oh, but if only this was the truth, because if it was then we wouldn't have the abortion which is GL3.1, instead we would have got Longs Peak, a nice new clean API which would have been better than D3D10 and probably D3D11. However, despite it being 'almost ready' for some time it died a silent death due to corporate reasons behind the scenes.



During those 8 years of usage I watched the ARB fumble and fail with OpenGL as MS learnt from its mistakes and improved the API with each iteration. The Longs Peak/GL3.0 mess was the last straw for myself and many others before they departed the API for a company who seems to know what they are doing.



Finally, while I have no direct quote handy, Carmacks most recent comments about D3D indicates that he likes what MS have done with it. The fact that everyone pulls out that 10 year old quote to try and attack D3D is a sad statement about OpenGL as well.



Until OpenGL gets all the features, the docs, the tools, the support and the stability of drivers that D3D has it is going to be on a losing footing and the ARB has, in the last 10 years or so, shown no indication that it can pull this off. As a developer this is what matters the most.



MS might well have a 'strangle hold' on things but at least they are getting things done.

Chris Howe
profile image
If you are targeting all the major PC platforms (Windows, Mac, Linux) then I guess this issue might be important. For console developers though you are always going to have to write different rendering code for each platform. On 360 you have a close relative of D3D. On PS3 you have OpenGL ES and CG. On the Wii you have GX, which might look similar to GL on the surface, but they aren't the same thing.



The most important part of the article IMO is this:



"It’s interesting how little of the technology cares what API you’re using and what generation of the technology you’re on. You’ve got a small handful of files that care about what API they’re on, and millions of lines of code that are agnostic to the platform that they’re on."



The actual API code should be a very thin layer so you should be able to adopt whatever is best for each platform.

Toby Youngberg
profile image
I found the article at least interesting, if not fairly biased. I just thought I'd throw in my two cents, as I recently wrote the same renderer with both OpenGL and DirectX 9.0c



From what I've been able to tell, there are positives and negatives to both platforms. On the OpenGL side, it was fairly straightforward to build a dynamic renderer that allowed any data to be selected in mostly any order, and then render with it, which was a requirement for our particular renderer. DirectX 9 requires very specific steps to prepare for rendering, and if not performed in the right order, nothing works. I was able to work around it to get the same functionality, but it wasn't quite as clean. Now, this is most definitely a problem with DX9, and DX10 and 11 mostly fixed it, but we have to target clients on XP, so 10 and 11 weren't an option.



Another thing I noticed was that DX9 has taken a somewhat "kitchen sink" approach in their API. For instance, why should my Rendering API include things like quaternions, and a 3D file format loader? Granted, these components are mostly part of D3DX and not D3D proper, but it still seems interesting to me that they felt the need to incorporate these features in a rendering API, when most engines have to handle this themselves regardless. To me D3D has become a Game API period. When it comes to other uses, like Video effects, or CAD it falls somewhat short because of the dynamic requirements of those uses.



On the other side, OpenGL has a few shortcomings as well. First and foremost, (and this is partly Microsoft's fault here for their odd context handling) it is what I would consider an absolute headache to build a multi-threaded renderer using OpenGL in Windows. With all the resource sharing and context switching necessary, it becomes fairly unruly fairly quickly, and becomes pretty tough to find problems. Not only that, but multi-threaded initially ended up slower than synchronous mode, because we had to switch contexts so much. We have since ironed out most of the problems, but I'm just saying that when I built the DX renderer, asynchronous just seemed to work with normal locking mechanisms and not much else. This was a pretty big win, but it also underscores what I would consider to be a problem as well. This wasn't necessarily a problem with OpenGL itself. This was a problem with the Windows platform, and I don't have nearly the problems with it on other platforms.



The other issue is the necessity of Extensions for anything beyond OpenGL 1.1 on Windows. Once again, this is a platform gripe, but it is nonetheless ridiculous that I should have to create a temporary context to retrieve the addresses of the functions for things like multi-sampling, then destroy said context and create a new one using the now exposed extensions.



Finally, the API in OpenGL has grown fairly archaic in the last few years with all the backpedaling when it comes to the new API we should have gotten with 3.0 and 3.1. Immediate mode should have been ditched years ago in favor of streaming vert data. It's slow, and has become a crutch for many apps that I've used that could benefit greatly from the speed bump that vertex arrays could offer, *cough* blender *cough* (although, to be fair, 2.5 will fix this most likely).



In the end, I think it really becomes a matter of preference. I actually prefer OpenGL to DirectX, but mostly because I don't work on Windows except for my day job. I feel that either API can work well, as long as it's treated like a first class citizen on the platform, and sadly OpenGL is not on Windows, and probably never will.



Anyway, just my 2 cents like I said.

Giuseppe Navarria
profile image
I love your team and Overgrowth but this article is truly unfair, when you say "OpenGL is Cross-Platform" you're speaking mainly about OpenGL ES. OpenGL runs only on PC.

Also let's clarify that PS3 doesn't use only OpenGL ES and Nintendo WII has his own SDK and libraries.



OpenGL API structure is bloated, outdated, not object-oriented and should be rewritten from scratch, DirectX SDK not only includes a graphic library (Direct3D) but several other kind of libraries and tools. And better to not even start talking about D3DvsOGL APIs documentation ;)



OpenGL isn't actually that open, it's in the hands of the mayor companies of the Khronos Group (Apple Inc., Intel, Nvidia, Sony, Sun Microsystem to name a few) and it's not you nor me that decide anything over it.



About being "the future" and "more powerful": OpenGL only recently deprecated the use of non vertex-buffer based geometry and the structure is still chained to a lot of deprecated garbage, and there are no plans to get rid of that in the near future.



I've build our own engine with both an OpenGL and a Direct3D renderer plugin and guess what, the D3D one is clean and slim, the OGL one was a lot trickier to do.



Direct3D is a much, much better API than OpenGL, even Carmack that's a member of the Khronos Group admitted it.

Over this practically objective fact, both APIs are just tools, if you need to develop for something that's not DirectX compatible you can surely bet on OpenGL, If you aim at at PCXBOX you're in DirectX realm. If you get an engine that can use both, that's even better.





In the end, OpenGL is a necessary evil for a lot of platforms, but it should copy DirectX and improve. Saying that OpenGL is better is covering his own eyes, OpenGL sucks. But it's the only thing you can use in a lot of cases.





Just for the lulz I'll drop this video here:

http://www.youtube.com/watch?v=sddv3d-w5p4



It still has a lot of truth behind :P

Mohanad Atta
profile image
thanks for the vid, it's really funny :)

Timo Heinapurola
profile image
I thought hard about whether to comment this discussion, since I'm personaly getting a bit tired of the eternal battle between DX and OGL. The only reason why one should care, is if the engine is directly using either API for rendering without a HW abstraction layer in between. That's a bit nutty IMO anyway. But then again... The more options there are, the better? Not necessarely, but it sort of keeps the circus running and new features coming in, perhaps at a quicker pace, when there's a bit more presure on MS, as there's the option of releasing the next fantastic feature on a new gfx board before a new DX revision comes out, since you can add support for it as an extension on GL. But it's a bit unclear whether this will happen anymore, since GL does have such a small slice of the pie nowadays. It's all about seasonal releases with "DXxx" on the box, anyway, without much in the way of incremental additions.



Btw. Giuseppe, we found that what worked best for us on our GL renderer was that a single thread runs the GL context and the others use a light weight command buffer to send commands to the executing thread.

Eric Harty
profile image
Where OpenGL is gaining ground is on smartphones where it is the only option for iPhone and BlackBerry. Additionally Microsoft's influence in this area is quickly approaching zero...

Sean Maples
profile image
I have a hard time believing a lot of his points just because of the tone of the piece; it reads like a fanboy rant.

Stephen Chin
profile image
I'm agnostic - I'm a designer and not a programmer so most of the nitty gritty details don't pertain to me. I'm posting though because I do have something to correct in the blog.



DirectX 11 -does- support DX10 and DX9 hardware. It basically has feature levels that scale back depending on hardware. So DX11 works on DX10 and DX9 hardware; by proxy, it works on W7, Vista, and XP. There's no locking out as with DX10 - and likely one of the reasons for this addition to DX was because of the problems MS had with DX10's Vista+ exclusivity.

John Byrd
profile image
For some reason, programmers freshly graduated from college seem to love the OpenGL/D3D religious debate. Most of us grayhairs find the whole subject tedious.

Joe Cooper
profile image
I thought a main different was that OpenGL is meant to not expose the hardware's capabilities? If the hardware can't do something, it does it in software. Really, really slowly.



When I was learning to program, I was playing with OpenGL and I tried accumulation buffers. I have a GeForce2 at the time. Well, the consumer grade GF2 did _not_ support accumulation buffers. OpenGL still listed it accumulation buffer capable, cause it was telling me the capabilities of the OpenGL implementation, NOT the card. Took some digging to figure out why it was going so slow.



Which is cool if it absolutely must work, period, but we're talking about games here; they absolutely must work _fast_.



I haven't worked with DX, but IIRC, the point was that it tells you what the hardware actually does and won't fake it. If it falls back to software, the game might as well not be played at all. It'd be too slow.



Wouldn't this make DX more appropriate if you don't know exactly what you software will wind up running on?

Matthew Pettineo
profile image
What's not mentioned in this article is the fact that IHV's have been adding their own "extensions" to D3D for many years now. This includes hardware shadow maps, R2VB, and (you guessed it) ATI's tessellation unit featured in their DX10 parts. Also not mentioned is that the programmable tessellation available with their DX10 parts is quite a bit different from what you get with DX11.



But ultimately this whole business is quite silly...any decent engine will have the API abstracted out to the point where you could support both if you really wanted to. This leaves you free to use whichever one works best for a particular platform (which is D3D, in the case of Windows).

Teri Thom
profile image
The only thing even remotely close to a fan boy rant in this article is the title which admittedly could have been "The pros and cons of using OpenGL or DirectX" instead of taking sides. Why viewers have to jump on writers who obviously take a lot of time to write an otherwise very good (more mainstream acceptable) article in public forums is beyond me. The writer clearly formatted his article well, inserted supporting links and graphics and gets my kudos for a well written piece. (With which I agree for our PC uses)



Now why should a mere artist have an opinion? Because working side by side with a cross platform (Mac/Windows/Linux) programmer for 10 years I have witnessed and felt the pain of just this issue. OpenGL has been the only reliable choice when using indie accessible engines like Torque & Unity. DirectX has failed us miserably, biting us in the butt at crunch time more than once. True it depends on the engine and programmer's knowledge to make it work, but OpenGL has never caused such pain.



I very much enjoyed the article and a good deal of the information offered back in the responses, though not at all the unnecessary flames. As for using the article to promote the product, props to you!

Benjamin Quintero
profile image
green apples vs. red apples. both taste great.

Dean Wadsworth
profile image
I love how people "claim" to have all this experience.. Reality is if you have all this experience, then you know it's the right tool for the right job, plain and simple. If you're a Windows and Xbox only game studio then it makes sense to specialize in DirectX only. If you're a cross platform game studio then it makes sense to specialize in OpenGL.



OpenGL has been around a lot longer, lets face it. So this means they have more experience and have built on strong previous knowledge more so than DirectX has. This is just common sense. After all if DirectX was all that, then wouldn't the PS3 be using it, iPhone, PSP or DS. From a business standpoint if DirectX was superior then everyone would be using it.



PC is a dieing market. PWC reflects this http://www.pwc.com/gx/en/entertainment-media/index.jhtml .. So cutting PC out of the market (which is the larger of the two computer game markets) really Xbox is the only console using directX of any decent sales market size. So from a business standpoint DirectX doesn't make sense if you want to reach maximum market.



Personally I'd like to see MS spend the money on improving their products instead of companies telling people how good they are. If they spent that time and effort improving their core products and DirectX it would benefit everyone over all, wouldn't it?



@Matthew Pettineo - Yes most engines have an API abstracted for graphics calls. Most adopt an OpenGL direct style calls and when it comes to supporting DirectX they just wrap OpenGL calls to DirectX. As for speculating on DirectX 11 and praising DirectX 10, most games today are still using DirectX 9c so the argument is moot.



@Bob Stevens - Most games today try to push the edges and boundaries of today's hardware. Games are more sophisticated today than they were 10 years ago and DEMAND more. So unless you're using an engine developed by a team who thought of EVERYTHING then maybe what you say is true. If so what engine are you using?



@Eric Harty - Have you been living under a rock?!? LOL! Sony is far bigger then MS, perhaps you've heard of them??? And it's not about faith my boy, it's about fact. So no need to believe, just look at what is staring you in the face. 8)



@Giuseppe Navarria - "OpenGL API structure is bloated, outdated" - that's just your opinion and in my opinion based on someone who doesn't have much experience. Also please post your links supporting "Direct3D is a much, much better API than OpenGL, even Carmack that's a member of the Khronos Group admitted it" I would like to read them. Also to clarify http://www.opengl.org/news/comments/sony_confirms_playstation_3_t
o_use_opengl_es/ do you have a news article that says otherwise? I know from working with the PSP that Sony has OpenGLES - ish wrappers around their own API (still not it's not DirectX-ish wrappers). As well many engines available for PS3 advertise OpenGLES. Can you post something supporting your claim?


none
 
Comment: