That's the sort of question that sparks off large scale flame wars, you know :wink: I'll still answer it tho.
Both have advantages and disadvantages. A quick summary:
Direct3D
-----------
Pros:
-Integrates with other DirectX components for sound, video, etc.
-Sometimes better driver support (depends on the manufactorer)
-Don't have to worry about extensions
Cons:
-Windows only
-MS only support it under VB/C++ (you can get it working on lots of other things ... but no official support)
-Have to deal with COM (ie. not *quite* so simple)
OpenGL
------------
Pros:
-Cross platform
-Easier to start learning with
-Longer lifetime (ie. quite a few features, OGL has had for longer than DX has)
-Extensions
-More than one software renderer to plugin as well
Cons:
-Extensions
-Have to use something else for sound, etc, in a game
So ... what do I mean by extensions?
Well, OpenGL has a feature called extensions which means that if a card implements more than the minimum set of features, it can have an extension to let you access the additional features.
IE: All OpenGL supporting drivers will support basic features (texturing). Some (most nowadays, it has to be said) will support multitexturing, so they register an extension called GL_ARB_MULTITEXTURE (or something similar). If you want to use multitexturing you can't just use it - you have to check whether the card supports that extension; if not, do something else or at least report an error and quit :wink:
In DirectX in *theory* most of the features don't follow that pattern. Instead, if you try to use a feature the driver doesn't support, DirectX is supposed to try and emulate it in software.
So, for simple things, DirectX makes life easier because you don't have to worry about checking driver support and so on.
In practice, it makes little difference because if the card doesn't support something in hardware, you're often better off leaving it rather than letting the software renderer try it - software is sloooooow.
Also: it means for things like vertex shaders, under OpenGL each card reports and extension for vertex shaders. In DirectX, Microsoft adds shaders into the next version of DX, and the card manufacturers have to support shaders in their drivers.
Similar story there too. Under DirectX, all cards (that have shaders) will conform to the built-in DirectX shaders, so easy to use. Under OpenGL each card might well report a different extension (one per manufacturer, generally). Thats bad because your app has to support multiple methods of doing shaders. But it's good because you're going to get *full* access to each cards hardware features - under DirectX you might well just get the features MS decided DirectX would like to support.
Eventually, of course, the OpenGL authority will merge the separate shader extensions into one official shader extension so there's no problem there either.
