OpenGL vs DirectX

OpenGL vs DirectX? You decide, GO!

MY vote go's to OpenGL, read more here.

Please do some research first instead of jumping on the bandwagon...

wait for the recently announced directx 12 it might be better
also the only game i can think of that has opengl is runescape...so i'm going with directx due to me having more experience with it

Well personally I barely even know what openGL is. All the games I play are in DirectX so i assume that's the better program.

Lol, here is a small list of OpenGL games and applications.

Wikipedia link

Also, if you REALLY want your socks blown off check out Unigine. This engine is written completely in OpenGL.

out of the games listed there, the only one thats like "impressive" is nexuiz, rest is just a bunch of old games
not convinced openGL is better yet

EDIT;
nvm, thats the old one, not the remake
so i take that back
and after looking around and reading some stuff i'm pretty sure directx is better, or at least just as good as openGL

things

There are a few fundamental differences in the design of the two APIs, though:
- DirectX comes in fixed versions, whereas OpenGL offers a flexible extension system. If a hardware manufacturer wants to offer a new feature in OpenGL, he simply registers a manufacturer-specific extension and programmers will be able to use it within a week. Depending on programmer feedback and "usefulness", the specification might change and the extension might be promoted to EXT or even ARB status and eventually find its way into OpenGL core. With DirectX, you simply have to wait three years until a new major version comes out and (hopefully) implements the feature you want.

- The DirectX specification is a lot more strict as to how a driver/hardware implementation has to behave to get that Microsoft-Stamp-Of-Approval. DX9 went as far as describing exactly which pixels have to be rendered for a triangle in all possible corner cases, how texture sampling has to behave in all corner cases etc. etc. OpenGL on the other hand deliberately omits a lot of the details from the specification to allow the driver to do what it considers best/fastest. Which one is better depends on perspective - DirectX makes it harder for drivers to provide a fast implementation of the API, whereas OpenGL makes it harder for the programmer to provide a consistent experience across different platforms (MacOS can do this faster, while Linux is better with that access pattern, whereas Windows/nvidia recommends a completely different order of commands etc. etc.)

- DirectX compiles and optimizes shaders inside the API and only passes an intermediate blob to the driver, which then does the transition to GPU executable code. OpenGL instead passed the entire shader uncompiled to the driver and lets it do its thing. The DirectX way of handling things is better, in my opinion. The compiler frontend is the exact same, regardless of the driver, making sure that if a shader compiles on your machine, it will compile on everybody else's (which is not the case for OpenGL - always test at least on both nvidia/ATI cards before releasing something!). Also, DirectX tends to do a lot of code optimizations before passing the shader to the driver. In OpenGL, the driver has the full responsibility of doing the shader compilation/optimization, and from what I've heard, they don't optimize quite as well, simply because they don't want to bloat the driver even more with a massive compiler framework.

It is also worth mentioning that OpenGL got rid of all deprecated functionality since version 3.1 to reflect the fundamental changes of the graphics hardware underneath (i.e. everything fixed pipeline related is gone, like glBegin/glEnd). The new API is a lot cleaner and nicer to work with, but the learning curve is very steep. The old functionality is still available for quite some time, but it is recommended to switch.

With that being said, I personally find DirectX nicer to work with because I find the API more intuitive to use, but I much prefer OpenGL's extension system to DX's major version approach. But why not use both? It's not much of an effort to provide both an OpenGL and a DX backend (look at Max2D's driver approach) and you get the benefit of being able to choose whichever runs better on the current platform.
-----------------------------------------------
In general, Direct3D is designed to virtualize 3D hardware interfaces. Direct3D frees the game programmer from accommodating the graphics hardware. OpenGL, on the other hand, is designed to be a 3D hardware-accelerated rendering system that may be emulated in software. These two APIs are fundamentally designed under two separate modes of thought.
As such, there are functional differences in how the two APIs work. Direct3D expects the application to manage hardware resources; OpenGL makes the implementation do it. This tradeoff for OpenGL decreases difficulty in developing for the API, while at the same time increasing the complexity of creating an implementation (or driver) that performs well. With Direct3D, the developer must manage hardware resources independently; however, the implementation is simpler, and developers have the flexibility to allocate resources in the most efficient way possible for their application.
Until about 2005, another functional difference between the APIs was the way they handled rendering to textures. The Direct3D method (SetRenderTarget()) is convenient, while prior versions of OpenGL required manipulating pixel buffers (P-buffers). This was cumbersome and risky: if the programmer's codepath was different from that anticipated by the driver maker, the code would have fallen back to software rendering, causing a substantial performance drop. However, widespread support for the "frame buffer objects" extension, which provided an OpenGL equivalent of the Direct3D method, successfully addressed this shortcoming, and the "render target" feature of OpenGL brought OpenGL up to par with Direct3D in this respect.
Outside of a few minor functional differences which have mostly been addressed over the years, the two APIs provide nearly the same level of function. Hardware and software makers generally respond rapidly to changes in DirectX, e.g. pixel processor and shader requirements in DirectX 9 to stream processors in DirectX 10, to tessellation in DirectX 11. In contrast, new features in OpenGL are usually implemented first by vendors and then retroactively applied to the standard.

I like OpenGL more by far, I've touched on both lightly in the world of programming. I really like OpenGL because its multiplatform. Not that I hate Microsoft or anything, I just like multiplatform developing more.

Directx over opengl

Direct x duh

I prefer OpenGL.

OpenGL vs DirectX

Similar Threads

Tags for this Thread