Quote:Original post by Codemonger
What the renderer supports is irrelevant in general, if it does support doubles then great, if not, oh well, no loss.. using doubles will yield higher precision that you would loose over multiple calculations using floats. Just like timesteps in physics, the higher the timestep the better the resolution the more precision, the different the timestep and you will have a different output. The D3DX math library uses single precision floats (32 bits) so doing a bunch of calculations in sequence will yield a less accurate simulation model etc.. blah blah blah

If it is irrelevant, why did you claim that OpenGL supporting it was an advantage? I'm confused. Obviously, doing your OWN calculations on doubles might be needed but what has that got to do with the rendering API?

To the OP, what rendering API you use really doesn't matter that much. Look around for tutorials and example code and see if you find anyone of them better than the other. It's easy to switch once you have some experience anyway. In general I'd say that in the beginning OpenGL is easier to learn but when doing advanced stuff D3D is slightly better. The D3DX library is probably nice if you're just starting out.

Quote:Original post by GameCat
In general I'd say that in the beginning OpenGL is easier to learn but when doing advanced stuff D3D is slightly better.

Oh, you'd say that. So, tell us, what exactly makes it slightly better for advanced stuff ?

It's always the same pattern: "both are perfectly equal, it doesn't matter which one you choose, blablabla, BUT, is slightly more advanced."

No offense, but that is bullshit. I'm seriously getting sick of it. As a matter of fact, both APIs are *NOT* equal at all, both have their very specific strengths and drawbacks. It DOES matter which one you choose, depending on the domain you want to apply it to and depending on the application you develop.

Let's clear up a few "facts" (read: misinformation) that is often posted in such threads, shall we ?

-> OpenGL does in fact support double precision access points. It's incorrect to assume that no 3D hardware uses them. That's maybe the case for consumer level gaming hardware, but OpenGL is available for very expensive highend 3D system which in fact support double precision math in hardware.

-> In terms of cutting edge features, OpenGL has the lead due to the extension mechanism. Vendors can add new features to OpenGL by using an extension, instead of waiting a year for MS to update D3D. HOWEVER, often these features end up being vendor dependent (not always, though, for example render-to-vertex-array). So if you want to play around with the most cutting edge technology available right now, use OpenGL. If you prefer perfect vendor independence on a slightly lower technological level, use D3D.

-> D3D has the advantage of (almost) perfect standarization across all chipset manufacturers, since it is being developed by a single third party company. If feature A works on chipset X, then you can be pretty sure it will also work on chipset Y without maodifications. That's not always the case with OpenGL (although it's getting a lot better recently). On the other hand, MS does a lot of changed from one version to the next, which might break compatibility. OpenGL has always been backwards compatible.

-> Multiplatform argument. Everybody knows this one. D3D = Windows + Xbox, OpenGL = Windows + Linux + Mac + Unix* + various consoles - Xbox (unless it's hacked).

-> In the industrial, R&D, manufacturing, and military sectors, D3D is almost unheard of. OpenGL totally dominates these sectors. The reasons are historical for one, but also because D3D has this stigmata of a "video game API". That's partially true. Heavy duty OpenGL applications by highend vendors (eg. 3DLabs and SGI) are stress tested under conditions not even imaginable for D3D (due to its closed source nature). OpenGL is better suited for security critical and fail safe applications. Also, industrial applications often run on non-Windows systems, and/or use professional high end 3D chipsets without (or only with very basic) D3D support.

-> Easier to learn argument: irrelevant. Both are easy, if you're ready to learn a 3D API. If you don't understand either of them, then you should ask yourself if you shouldn't be learning programming basics instead of jumping into 3D graphics.

So at the bottom line, don't just pick one. You might regret it later. Analyze your requirements, make some research about the strengths of each API, make a PRO and CONTRA list. Discuss it with your team and select based on all these inputs, instead of basing your decision on the personal preference of anonymous (the irony...) OGL/D3D zealot number #549870-C.

Sheesh, relax would you. I did say that it was irrelevant what to choose. I do all of my hobby coding in OpenGL, so I'm certainly not some kind of D3D fanboy. That said, pbuffers are a pain in the arse and the MS HLSL compiler is much more mature than any currently available implementation of glsl which is why I said what you quoted. But this thread will just degenerate into a flame fest as usual, so I'll stop posting now.

Quote:Original post by GameCat
Sheesh, relax would you. I did say that it was irrelevant what to choose.

Well, it's not irrelevant. That's my point.

Quote:Original post by GameCat
I do all of my hobby coding in OpenGL, so I'm certainly not some kind of D3D fanboy.

I wasn't referring to you specifically, I was pointing out a usual pattern in such threads: a lot of FUD is sprayed in the light of defending the personally favoured API.

Quote:Original post by GameCat
That said, pbuffers are a pain in the arse

True, they are a pain to use (although they do work). The easier solution (http://www.opengl.org/resources/features/GL_EXT_render_target.txt) will probably be implemented very soon. I wouldn't base my long term selection on a criterion that will be obsolete in a couple of months. That's what I meant by "do your own research".

Quote:Original post by GameCat
and the MS HLSL compiler is much more mature than any currently available implementation of glsl which is why I said what you quoted.

HLSL isn't comparable to GLSL. The former was been around for ages, while GLSL is brand new, and still under heavy development. If you want something comparable to HLSL, try Cg.

Quote:Original post by GameCat
But this thread will just degenerate into a flame fest as usual

It doesn't have to, as long as people keep to hard facts.

Open Gl and DirectX are really just pipelines.
They are on a basic level,just means of accessing the hardware.

You are thinking about cross platform? then you will use OpenGl.
DirectX is for the windows platform only.

OpenGl is easier to start with as a beginner,though you will have to write your own functions for certain things that Direct graphics will save you from writing yourself or make things slightly easier to do for you.

In the end its really your choice,i would say give them both a try,to see which you prefer and find easier to code your project with.

I know you wanted to get the opinions from devs here before you jump into to either,though in honesty,it really boils down to which one different devs prefer and like better,and find easier to use.So you really have to find out that question for yourself -:)