Printable View
Hello guys!
I want to know what is the best, the fastest, the most powerful, the most difficult to learn, advantages and disadvantes in general between game programming in DirectX and OpenGl.
What´s your opinion? I have seen many very good RPG Games in OpenGL (like Regnum, www.regnumonline.com.ar ) and many others in DirectX..
Can anyone tell me? Thanks in advance!
Ignacio G.
I'd say learn whatever. It seems game makers use directx extensively. Learning the concepts of 3d programming is pretty much the same between the two, and probably the most difficult in learning to write 3d/game stuff anyways. If you understand what you are doing when you write 3d stuff in one API...you can probably use the other one effectively as well.
As to "which is most powerful" (or "best" in many other ways) it will probably depend on exatly what power you need/want. It's a bit like comparing a Ferrari F50 with a Ford Transit van - the Ferrari will definitely win the "fastest around the racetrack", but the Ford Transit will definitely win the "pack a lot of stuff in the back" competition. Likewise, there are things that OpenGL does better than DirectX, and there are things that DirectX does better than OpenGL. [Note that the Ferrari vs. Ford Transit example is a lot more extreme than the difference between DirectX and OpenGL - they are pretty similar in most ways, and it would probably be more of a case of a Vauxhall/Opel model X vs the corresponding Ford model Y comparison - I use the Ferrari vs Transit comparison because it shows that measuring different things "the best" is a different result- in real things the difference may be much smaller].
Learning 3D Drawing in general is no easy thing - there is a lot of math to understand (not complicated, but a lot of it). Particularly, matrix computations will be critical to understand. Once you understand the concept of movement/rotation using matrix operations, the rest of the 3D work will be fairly easy.
In the past, graphics cards have been designed mainly for OpenGL or mainly for DirectX, but in the recent years, I think most cards do both with pretty good results.
I'm sorry I can't just simply say "OpenGL is better because ..." or "you should use DirectX because ..." - but it's pretty much an arbitrary choice unless you have specific requirements. For nearly everything, you will be doing the same work, the performance will be pretty much the same (limited by some hardware component - for example one of: graphics processor, main processor, main memory bandwidth, graphics memory bandwidth or the bus that the graphics card sits on).
--
Mats
I guess an advantage (subjective I suppose) of OpenGL is it could be cross platform.
Other than that is just is going to depend on what you're doing whether one proves more difficult or not.
OpenGL is just a standard, it specifies nothing about performance that's strictly implementation dependant (esp. on hardware). As mentioned above, the hard thing is not the API it's the concepts. You'll need a very firm grasp of maths. D3D has good commercial backing, so does OpenGL (in a way...). Which is one of the main reasons D3D is so popular for commercial titles.
Personally I'd say go with OpenGL because it's portable, and very nice to use :-). Although I've never programmed with DirectX before.
> I use the Ferrari vs Transit comparison because it shows that measuring different things "the best" is a different result
And you drive a Ford Transit? :p
Which API you use is really up to you. All of the benefits and disadvantages have already been mentioned in this thread.
We really can't tell you which one and there is no right or wrong answer here. Learn the principles and then you can apply them inside of whatever 3D API you want to use.
It's also a question of the language you use. If you use C++, you really have the choice. If you use any .Net language, DirectX is much better supported. If you use C, you're better off with OpenGL, because interfacing with COM libraries in C is beyond ugly.
OpenGL. I can't stand programming just for one operating system only.
DirectX. I cannot stand slow-evolving APIs that are falling behind time ;)
Besides, it also has APIs for other things than just graphics - input, sound (or was this deprecated?), etc.
> I cannot stand slow-evolving APIs that are falling behind time
Howso? :\
exclusive OO is not the "future".
Of course, this was just an individual opinion against the other "opinion", simply because opinions are not facts, and you should not choose an API depending on opinions.
That said, OpenGL is having trouble right now. The newest revision brought nothing but disappointment and anger from the community, and I like having lots of powerful features - and fast! I do not like waiting lots of years between revisions, and seeing as DirectX was created after OpenGL, and is now equal or surpassed it, it is quite obvious that it is evolving faster.
Exhibit A: Unreal Tournament 3
By now you can probably see that it will be a matter of preference. Yes, DirectX may be changing constantly but that can be viewed as good or bad depending on how you approach it. Unreal Tournament series is a good example of a game that give you the option of Direct X and OpenGL. Which will really show you that it is almost completely preference.
If both of them fails, try to use software (GDI/?) the slowest 3D driver but the most portable ever.
And also the slowest, probably failing to reach playable speeds.
Heh, I would argue that OpenGL is more portable than any low-level 2d API you can find. There are very portable wrappers, but they come with trade-offs.
I started using OpenGL but I have to admit the procedural nature of the API bugs me, being a heavy OOP person. While it's easy enough to find the functions you need, since they are all named accurately to what they do, the convoluted state machine that you end up having to manipulate is difficult to reference for me. I started XNA recently and like the approach it gives, I may move to DirectX hopefully without too much effort. Personally I don't mind it not being portable though I've played some great games that are done in OpenGL.
The main difference is if you need tools that do something like load textures, load 3d models, in OpenGL you merely need to find a library that does it and include it in your project. Most of that "basic" functionality as far as gaming goes is already implemented. I think that's what Elysia means by more evolved, it just has more tools that one would need when using a 3D programming framework.
Evolves means that it has more functionality. Look at the release date of DX11 vs OpenGL Next-gen.
Functionality is added and the API is refined more often than OpenGL.
> Look at the release date of DX11 vs OpenGL Next-gen.
And does it run on my platform of choice? No. That makes it 100% useless to me.
OpenGL is not supposed to be a rival to DX at all. It does however provide similar functionality as D3D. If you want some big-ass toolkit with sound, networking, etc and OpenGL as a renderer they do exist.
Does it run on the platform of my choice? Yes :)
Anyway, it is not supposed to be a rival, but I like faster evolving APIs.
But pick the API you think if best with the facts provided. That probably is a good answer.
OpenGL on XP and Vista is implimented using DirectX calls. So realistically it doesnt matter which one you use, the are both nearly equal in speed. OpenGL does have the advantage of being (more) multi-platform than DirectX, although that is changing as more platforms support DirectX.
The Vista built-in OpenGL is, but that one is useless anyway, since it's completely outdated. (OpenGL 1.1 or something like that.)Quote:
Originally Posted by abachler
The hardware vendor OpenGL is not. ATI and nVidia supply their own OpenGL implementations.
Using OpenGL or Direct3D is a moot point. Pick your poison and move on. If you have no clue about 2D/3D graphics fundamentals then you will be equally as stuck in both APIs. And since you are asking this very simple question that can only be decided when/if you understand what each API brings to the table I would say you are not ready to make the call yet.
Read some books about graphics. Some of them use OGL and some use D3D. Some of them do not use any API. My favorite books are books that concentrate on concept rather than implementation. I would rather read an entire graphics book with very little source code than some hard-coded tutorial that you run through in the book. Most books have gotten away from piling on reams of source code and instead have a website or CD that comes with the book that contains the source.
You will need to check multiple sources before coming close to being able to create a game. Remember in English when your professor said you need at least 10 to 15 sources for your paper? No different here. You will need many sources to get the information you need. One book may say a certain topic is beyond the scope of the book while others may dive into it headfirst. Do some research, for goodness sake get some code working, and then wash, rinse, and repeat about a million times.
To be fair opengl has alot more ppl to go through, an entire board of people with different objectives in life, to be updated. Where directx is a microsoft thing ONLY. Im not saying that opengl isnt slow moving but that is has to go through more ppl with different objectives before it gets updated.Quote:
Originally Posted by Elysia
I would say DirectX has to go through more red tape before getting updated. It is far more difficult to get something updated in a large company like Microsoft than it is for an API that isn't really maintained by one large company.
As it stands there really isn't an excuse for the current state of the OpenGL API.
I would dearly love to see OpenGL picking up speed, reforming & all that. It seems OpenGL is in a pinch right now and they need to solve it. But until they do, I will favor DirectX instead.
I would also dearly love to see OOP out of OpenGL. Currently, it's just C, no?
At least DX is built upon Microsoft's stupid COM which works in both C and C++ in an OO way.
Well, OpenGL 3 was supposed to be object-oriented (on a conceptual level - but it would have been easy to wrap in a few classes). Of course, that was postponed.
Don't bother learning low level 3d graphics programming until you've used a high level graphics library such as SDL, Irrlicht, OGRE, Flash API, etc. Create your own little wrappers. Write something useful. Eventually go back and replace the core with your own OGL or D3D implementation if you're actually up to it.