If OpenGL is supposed to be just as good if not even better than Direct3D (Not talking about DirectX here), then why don't developers use OpenGL to program their games generating some extra sales on GNU/Linux and Macintosh?
They're game developers, what'd you expect? They just use whatever MS bribed their school to teach them.
Name:
Anonymous2010-02-21 18:16
DirectX works for what it does. OpenGL only handles 3D graphics. This means that the programmer needs to find other libraries to handle what DirectX does.
Name:
Anonymous2010-02-21 18:17
Writing code for multiple platforms goes FAR beyond the choice of graphics API.
Because Microsoft is made of greedy, monopolizing fucks.
1. Microsoft pays graphics card designers to purposely gimp their OpenGL performance. When you buy a "workstation" card, you're getting almost the exact same thing as the equivalent "consumer level" card, but with a slightly different firmware.
2. Microsoft pays game development companies to spend more work on the D3D renderers than on the OpenGL renderers
On top of that, D3D is a horrible mess of a library. Its only saving grace from a design standpoint is that it's tightly integrated with other game-related libraries (DirectSound, etc) so that developers don't have to spend forever trying to figure out which libraries to use along with their OpenGL instance/whatever.
Similar to what has already been mentioned: OpenGL and DirectX technologies may be similar (or perhaps OpenGL better), but DirectX comes with a full suite of tools, libraries, and development pipeline. It tries to be a full solution from start to end, while OpenGL is just the rendering part.
>>1 (Not talking about DirectX here),
Oh, how wrong you are. DirectX has almost everything to do with it. It's a package deal. It's not a fantastic one, but it covers all the bases. OpenGL does not.
A more interesting question is why did Microsoft not use OpenGL for their Direct3D component? The answer is that they decided that OGL was inefficient, built D3D and OGL implementations, screwed up the OGL one and (erroneously) Q.E.D.'d D3D to be the winner.
At that time D3D was especially bad technologically, and some dude came along and proved them wrong about OGL's efficiency. The problem then being that they'd already built their DX monolith (at least in definition) by then, and it stuck. (Not like they would have listened anyway.)
BTW, PS3 game developers [biou]do[/biou] use OGL. The upshot is that XBox "exclusives" almost always get PC ports at some point, and PS3 exclusives never end up on a Linux PC because you can't sell anything that isn't drenched in patchouli oil to hippies.
Name:
Anonymous2010-02-22 17:39
>>20 patchouli
Smelling patchouli is like trolling my nose.
Name:
Anonymous2010-02-22 17:41
>>21
I do like the smell of it, but I can never get them hippies to buy my video games.
Name:
Anonymous2010-02-22 18:38
You wanna know why? OpenGL sucks. There was a time when OpenGL was good; most actually preferred to write using OpenGL than Direct3D. Then Microsoft said "No.", and ever since then Direct3D has been infinitely better than OpenGL.
Name:
Anonymous2010-02-22 18:45
>>23
You'll have to be a bit more specific with that story because I lost the narrative causality at the point where you said "Microsoft said 'No'."
What is it that D3D can do that OGL can't?
If I were a game developer(I'm not), I'd rather write the 3D subsystem in OpenGL than in Direct3D, for portability reasons(*nix, consoles,...) and that it's less bloated than D3D. And this is coming from someone who actually likes Microsoft's APIs (Win32 and friends).
>>28
Does the 360 not support OpenGL at all? >>27
Should have expected this response. I know it's the usual response to such things and I should not bother responding to trolls, but the whole thing about many parameters being NULL is just an inadequency of C's parameter list design. Unlike more high-level languages, C doesn't have support for comfortable support for: optional arguments, keyword arguments or variable number of arguments. (okay, you could use varargs to get support for such things, but it'd be more work for little gain, since C doesn't have a powerful enough macro system). So you pass NULL for arguments that you don't care about, instead of having some keyword arguments which your compiler could translate into appropriate calls. That said, NULL args are more efficient than direct keyword args as the arglist parsing is done by the programmer(human compiler), however it would be possible to do such transformations to keep the efficiency using a real macro(in a powerful enough language) or a compiler.
Example:
fun1 has 6 arguments: a,b,c,d,e,f
You only care to pass 2 values, c and f: fun1(NULL,NULL,1,NULL,NULL,NULL,2);
In another language which supports keyword args: (fun1 :c 1 :f 2) ;Much clear isn't it?
Now the compiler has 2 options, either pass '(:c 1 :f 2) as a list, and do the arglist parsing/destructuring in fun1 (slower, how it's usually done as someone might want to pass unknown arguments), or the arglist parsing can be done using a compiler macro which transforms it into a call like (fun1 nil nil 1 nil nil nil 2). C doesn't have easy support for such code transformations, and MS chose it to implement their OS (and C++ for less important client applications). [m]NULL, NULL, NULL[mm] are the cost of their compromise. It could be easily solved, but it won't be as long as they stay with vanilla C. (Reducing the feature-count is a non-solution for true ``ENTERPRISE'' flexible applications, so don't even mention it.)
>>29
No function should use so many parameters at the same time, even if it did it would use separate params at separate times within its block. So a well-designed API would define more functions that use less parameters, such that a programmer could call two or three functions instead of wasting readability on one with a dozen NULLs.
It would of course have to assume they are being called in the correct order (or at least check for that). Which is harder to spot - calling init_that_thing before init_this_thing, or putting NULL, NULL, NULL, NULL, 6, NULL, NULL, NULL instead of NULL, NULL, NULL, 6, NULL, NULL, NULL, NULL?
Name:
Anonymous2010-02-23 7:06
>>35
Which is worse, knowing everything you need to know up front, or having a mandatory dependency in a completely different place?
I can either go to line n and know all the clues I'll need to solve the problem, or I can hope that the documentation was good enough to explain the expected order of operations that I would have otherwise had to guess.
But seriously, I'm not advocating for either way. I'm sure there are instances where more functions would have worked better than more arguments in the Windows API (but then you run into the ProcExEx problem...). Eventually a programmer is going to have to put up with some complexity when working with a complex system. Especially in such a straightforward language as C.
>>35
Most people use some sort of IDE that looks up the function prototype and highlights the current function/argument, so getting the order wrong is rarely an issue. Sometimes I write ANSI C in simple editors and do get argument order wrong, even in functions with small argcounts (3+, for example, I don't remember how many times I looked up fseek/fread's definition).
As for redesigning the function APIs, I think it would be rather tricky to do given Win32 APIs features and complexity.
Most people use some sort of IDE that looks up the function prototype and highlights the current function/argument, so getting the order wrong is rarely an issue.
It is problematic to require an external tool just to compensate for the problems of a language or library design. Most people recognize this, and just hold their nose when they have to use the language and/or tools. But not you!
Name:
Anonymous2010-02-23 10:00
>>38
Computers exist to solve information problems for the users. If you're not writing code in paper, I don't see why you shouldn't make use of a computer for a job that its designed to perform.
Name:
Anonymous2010-02-23 10:33
>>37
That APIs add no value and are good only to make you an mstarded faggot who cannot use standardized interfaces to do shit and secure your otherwise worthless existance. And if you don't get it then go die now.