Slashdot Mirror
OpenGL 3.0 Released, Developers Furious
ikol writes "After over a year of delays, the OpenGL ARB (part of the Khronos industry group) today released the long-awaited spec for OpenGL 3.0 as part of the SIGGRAPH 2008 proceedings. Unfortunately it turns out not to be the major rewrite that was promised to developers. The developer community is generally furious, with many game developers intending to jump ship to DX10. Is this the end of cross-platform 3d on the cutting edge?"
Yes and No. WINE has a very nice implementation of DirectX 9 that seems to run my games very bloody well. And no, I am not using real windows binaries.
"When life gives you lemons, don't make lemonade. Make life take the lemons back!" -- Cave Johnson
Cross-platform 3D is useful, but OpenGL stopped being cutting-edge many years ago. The model that it uses is falling farther and farther from the model that the hardware supports, and many new extensions and features are not supported on many platforms (particularly ATI). It has become increasingly difficult to write cutting-edge graphics software, and OpenGL 3 does little to fix that.
Ewige Blumenkraft.
Part of the reason for DX's success is that nobody else seems interested in developing anything to compete with it. OpenGL is the only cross platform 3D API I'm aware of and it and DX are all that there is these days. GLs problem is that it isn't keeping up with the hardware. The "just use vendor specific extensions" isn't a realistic solution in most cases. Thus GL is suffering and DX is winning by default.
If someone like Apple did develop a good 3D API, it might do well. However nobody seems interested.
The PS3 uses OpenGL ES for basic rendering (GL with all the ancient cruft ripped out) and NVIDIA's Cg for the actual shaders.
That's most of the problem though... they did rewrite OpenGL, then they scrapped it. So in the process, we got a few years of the new version not existing. And a year of communication (from ARB/Khronos) not existing, particularly frustrating after they'd spent the previous year saying they were going to work on communications and transparency.
Even better, GL2 was supposed to be a cleaned up API, so this was the second time they promised a rewrite and scrapped it.
So either they were completely wrong about the justification for the rewrite both times (which doesn't bode well for the group in charge of the API) or we are missing out on the benefits the rewritten API would have provided.
Probably the biggest problem was the communications though, if they'd admitted the problems as they happened, there probably would have been less backlash. As it is, everyone was still pretty much expecting the original 3.0 design, so not getting that, on top of a year's worth of promised status updated, on top of the previous poor communication the promised status updates were supposed to fix, on top of the promised-then-scrapped 2.0 update, etc. leads to unhappy community.
(For those not following the situation, advertised benefits included:
simpler api = simpler drivers = better conformance + fewer driver bugs
new object model = less need for consistency checking in drivers = faster drivers with fewer bugs
getting rid of outdated code paths = easier to understand the api, easier to tell what will be fast
probably some more I forgot)
Thing is it's not even close to being easy to use anymore. Especially not if you're interested in performance.
Because of the two decades of crud that has accumulated, there are so many ways of falling off the fast path in OGL, and it's next to impossible to know beforehand what will and will not work. Drivers are also a bitch to develop and maintain because of the size of the thing, which makes things even worse since what works on Nvidia may not work on ATI and vice versa.
The only way to fix this is a good cleanup to bring it in line with modern hardware. What they did was add even more crud.
.
Vista is approaching 20% of the market. Top Operating System Share Trend You can't expect expect Linux ports if entry level DX9l/DX10 outperforms OGL.
...and probably irrelevant in the longer term.
This is not the first time this has happened. GL2 was also supposed to be a cleanup, but turned out to be anything but. This latest fiasco is more significant as a failure of governance than of technology. All the right ideas were there; they were published in some detail over a year ago in the Pipeline newsletters. But the ARB very obviously a) can't agree to get anything meaningful done, and b) now has subzero credibility with developers. It's not coming back from that.
So yes, I think cutting-edge cross-platform 3D is dead for the next 2-3 years. Let's face it, it was never exactly healthy. It's not the end of the world. Linux share is currently growing mostly at the low end, netbooks etc, while the Mac seems to be thriving despite the fact that Apple doesn't give a flying fsck about gaming and never has.
Fast forward a couple of years, though, and things like Larrabee will be hitting the market; embarrassingly parallel hardware that can be programmed with standard languages and tools. The API's role as gatekeeper of functionality will be gone. And suddenly, 3D rendering libs can be written by anyone with the time and expertise, without having to go through Microsoft or the ARB or NV or AMD/ATi or Intel or anyone. Experimentation, competition, cross-fertilization, evolution. Remember Outcast's voxel engine? Seen things like Anti-Grain? This will happen.
(Or, yes, people could just reimplement the DXwhatever API directly, but that would be a little disappointing.)
Today was not a good day, by any stretch of the imagination. But it's not the end.
Well, it is a Microsoft product, so it's not without its flaws (The Vista dependency for one), but over all it's a good API for taking advantage of modern hardware without all the legacy crud that plagues OpenGL.
If you've used D3D8 or older, you'll find it a massive improvement.
OpenGL ES (PSGL) is provided, but I don't think anyone is seriously using it except to do initial porting efforts.
Sony supply an alternative low level api called libGcm.
That's an old perpetuated myth, that the value of D3D has anything to do with the satelite APis.
Let's confront it with facts:
- Direct3D is the absolutely dominant component of DirectX, in terms of received and deserved attention by users. As well as R&D effort by MSFT. It's the advancement of D3D that drives MSFT to release every next version of DirectX.
- Each component of DX is a completely indepependent API, sharing only design convention. OpenGL games on Windows use DirectInput for input, perfectly ignoring Direct3D.
- funnily, the satelite APIs are actually being phased out by MSFT. DirectPlay was always thoroughly ignored by the industry. For DirectSound and DirectInput there are replacement already. Not to mention the fate of hardware acceleration of DirectSound in Vista.
D3D and DX are de facto interchangable terms. Get over it.
Not handling sound/input by OpenGL is absolutely irrelevant in discussion about it's applicablity.
the legacy crud that plagues OpenGL.
Did you read "the deprecation model" (appendix e) of the OpenGL 3.0 spec? OpenGL 3.0 apparently provides for a mode (a "forward compatible context") that helpfully excludes deprecated "legacy crud".
This sounds very handy for people trying to update codebases - they can presumably switch to a forward-compatible context, do a build, see what breaks.
Choice of masters is not freedom.
AFAIK you cannot use the dependency resolution logic of apt or yum or w/e without also divulging the source code something which is never going to happen with commercial s/w.
kjella@desktop:~$ dpkg --info opera_9.51.2061.gcc4.qt3_i386.deb
new debian package, version 2.0.
size 8295240 bytes: control archive= 6485 bytes.
34 bytes, 2 lines conffiles
1275 bytes, 21 lines control
16580 bytes, 231 lines md5sums
1719 bytes, 54 lines * postinst #!/bin/sh
572 bytes, 18 lines * postrm #!/bin/sh
179 bytes, 9 lines * prerm #!/bin/sh
Package: opera
Version: 9.51.2061.gcc4.qt3
Section: non-free/web
Priority: optional
Architecture: i386
Depends: libc6 (>= 2.1.3), xlib6g (>= 3.3.6) | xlibs | libxmu6, libqt3-mt (>= 3.3.4), libstdc++6
Suggests: flash-npapi-plugin | flashplugin-nonfree | swf-player | libflash-mozplugin | mozilla-plugin-gnash, pdf-npapi-plugin | djvulibre-plugin | mozilla-acroread, cupsys-client | lpr, sun-java6-jre | sun-java5-jre | java-gcj-compat, linux-libertine | ttf-dejavu | ttf-bitstream-vera | msttcorefonts, xine-plugin | gxineplugin | mplayerplug-in | kaffeine-mozilla | mozilla-mplayer | mozilla-helix-player | gecko-mediaplayer, mozplugger | plugger, mozilla-bonobo, aspell
Conflicts: opera-static
Replaces: opera-static
Provides: opera-static, www-browser
Installed-Size: 20100
Maintainer: Opera Packaging Team
Bugs: mailto:packager@opera.com
Description: The Opera Web Browser
Welcome to the Opera Web browser. It is smaller, faster,
customizable, powerful, yet user-friendly. Opera
eliminates sluggish performance, HTML standard violations,
desktop domination, and instability. This robust Web
browser lets you navigate the Web at incredible speed and
offers you the best Internet experience.
The binaries were built on Debian using gcc-4.0.0.
I think someone sent us a telex saying they want their troll back.
Live today, because you never know what tomorrow brings
MPC: So, you said Rage is a 60Hz game. Is it an OpenGL or DirectX game?
JC: Itâ(TM)s still OpenGL, although we obviously use a D3D-ish API [on the Xbox 360], and CG on the PS3. Itâ(TM)s interesting how little of the technology cares what API youâ(TM)re using and what generation of the technology youâ(TM)re on. Youâ(TM)ve got a small handful of files that care about what API theyâ(TM)re on, and millions of lines of code that are agnostic to the platform that theyâ(TM)re on.
MPC: Are you using DirectX 9 equivalent? For Doom 4 as well?
JC: Yes to both. Itâ(TM)s one of those things I get asked a lot. Whatâ(TM)s big and exciting for DirectX 10 or DirectX 11? Thereâ(TM)s not a whole lot of⦠really not a whole lot. The big touted geometry shaders were in many ways, a mistaken belief that people desperately wanted to create stencil shadow volume.
So less than a month ago John said that he's still developing with OpenGL and that DX10 isn't really a worthwhile improvement.
And congratulations on referring me to something he said ages ago, when you find something more recent feel free to reply
Oh and source of interview: http://www.maximumpc.com/article/features/e3_2008_the_john_carmack_interview_rage_id_tech_6_doom_4_details_and_more?page=0%2C0
All I've really seen of the PS3 dev kit is what was on display at GDC. The Sony guys talked about GL ES and NVIDIA's Cg toolchain for shaders, so that's what I posted. This, however, sounds a lot more like what I expected from Sony and is right in line with the PS2 dev kit (emphasis mine):
Sony supply an alternative low level api called libGcm.
If libGcm is what I think it is (macro'd constants to build push buffers + raw DMA access) then pretty much nobody will be using the GL stuff. Coding right to the hardware is what PlayStation development is all about.
Two words: Geometry Program.
What MS call "Shader model 4" (even though geometry programs aren't, strictly speaking, shaders as they don't necessarily SHADE anything per se) includes mandatory support for geometry programs.
The geometry program sits in the programmable pipeline between the vertex program (which is used for real-time vertex deformation in hardware, world-space to object-space clipping to generate texcoords for the fragment program, etc) and the fragment program (which is used to colour fragments [1] based upon the output of the vertex program and input from one or more texture samplers.)
Unlike "old" vertex programs, a geometry program is able to generate new geometry on the fly. This allows a whole heap of really cool stuff, such as real-time shadowing effects, for essentially free.
So, yeah, much as I hate to admit it (and REALLY hate the Direct3D 'shader' nomenclature concerning pipeline programs,) D3D10 actually has changes with merit from D3D9c.
[1] A fragment is a fancy name for a voxel defined in clip space. After shading and occlusion, the remaining fragments become rasterised as pixels. Thus, the term 'pixel shader' is rather inaccurate.
You're doing it wrong.
.
FIY:
We collect data from the browsers of site visitors to our exclusive on-demand network of live stats customers. The data is compiled from approximately 160 million visitors per month.
Additional estimates about the website population:
76% participate in pay per click programs to drive traffic to their sites.
43% are commerce sites
18% are corporate sites
10% are content sites
29% classify themselves as other (includes gov, org, search engine marketers etc.. About Our Market Share Statistics
Net Applications stats are global.
Its clients - for reasons which should be blindingly obvious - are interested only in meaningful stats about users, not licenses.
Plenty of people are buying computers with Vista and switching to another OS, or downgrading to XP.
The numbers simply aren't there to support this argument.
Take a look at this extension: http://www.opengl.org/registry/specs/EXT/direct_state_access.txt This is actually quite significant. I think it could form the basis of the object system that was promised but not delivered.
"Politicians and diapers must be changed often, and for the same reason."
Please stop modding up this troll.
That article is 6 years old.
Most of those patents are hardware patents totally irrelevant for OpenGL (or Direct3D for that matter).
Also, Microsoft is not a member of the group that actually writes the OpenGL specification. They have no vote on what gets in OpenGL or don't.
Of course this might give them leverage on some of the hardware vendors (like Nvidia) that will have to implement the new OpenGL standard in the future. But history does not show them trying to use this in any way against OpenGL.
But claiming they "own OpenGL" is nonsense.
Implements.
"When I first heard Daydream Nation it quite frankly scared the living shit out of me." -- Matthew Stearns
Basically they've got tangled in the implementation details and decided to play it safe with OpenGL 3.0 instead of starting from scratch.
========
What happened to Longs Peak?
In January 2008 the ARB decided to change directions. At that point it had become clear that doing Longs Peak, although a great effort, wasn't going to happen. We ran into details that we couldn't resolve cleanly in a timely manner. For example, state objects. The idea there is that of all state is immutable. But when we were deciding where to put some of the sample ops state, we ran into issues. If the alpha test is immutable, is the alpha ref value also? If we do so, what does this mean to a developer? How many (100s?) of objects does a developer need to manage? Should we split sample ops state into more than one object? Those kind of issues were taking a lot of time to decide.
Furthermore, the "opt in" method in Longs Peak to move an existing application forward has its pros and cons. The model of creating another context to write Longs Peak code in is very clean. It'll work great for anyone who doesn't have a large code base that they want to move forward incrementally. I suspect that that is most of the developers that are active in this forum. However, there are a class of developers for which this would have been a, potentially very large, burden. This clearly is a controversial topic, and has its share of proponents and opponents.
While we were discussing this, the clock didn't stop ticking. The OpenGL API *has to* provide access to the latest graphics hardware features. OpenGL wasn't doing that anymore in a timely manner. OpenGL was behind in features. All graphics hardware vendors have been shipping hardware with many more features available than OpenGL was exposing. Yes, vendor specific extensions were and are available to fill the gap, but that is not the same as having a core API including those new features. An API that does not expose hardware capabilities is a dead API.
Thus, prioritization was needed, and we made several decisons.
1) We set a goal of exposing hardware functionality of the latest generations of hardware by this Siggraph. Hence, the OpenGL 3.0 and GLSL 1.30 API you guys all seem to love ;\)
2) We decided on a formal mechanism to remove functionality from the API. We fully realize that the existing API has been around for a long time, has cruft and is inconsistent with its treatment of objects (how many object models are in the OpenGL 3.0 spec? You count). In its shortest form, removing functionality is a two-step process. First, functionality will be marked "deprecated" in the specification. A long list of functionality is already marked deprecated in the OpenGL 3.0 spec. Second, a future revision of the core spec will actually remove the deprecated functionality. After that, the ARB has options. It can decide to do a third step, and fold some of the removed functionality into a profile. Profiles are optional to implement (more below) and its functionality might still be very important to a sub-set of the OpenGL market. Note that we also decided that new functionality does not have to, and will likely not work with, deprecated functionality. That will make the spec easier to write, read and understand, and drivers easier to implement.
3) We decided to provide a way to create a forward-compatible context. That is an OpenGL 3.0 context with all deprecated features removed. Giving you, as a developer, a preview of what a next version of OpenGL might look like. Drivers can take advantage of this, and might be able to optimize certain code paths in the forward-compatible context only. This is described in the WGL_ARB_create_context extension spec.
4) We decided to have a formal way of defining profiles. During the Longs Peak design phase, we ran into disagreement over what features to remove from the API. Longs Peak removed quite a lot of features as you might remember. Not coincidentally, most of those features are marked deprecated in OpenGL 3
And the article text:
What happened to Longs Peak?
In January 2008 the ARB decided to change directions. At that point it had become clear that doing Longs Peak, although a great effort, wasn't going to happen. We ran into details that we couldn't resolve cleanly in a timely manner. For example, state objects. The idea there is that of all state is immutable. But when we were deciding where to put some of the sample ops state, we ran into issues. If the alpha test is immutable, is the alpha ref value also? If we do so, what does this mean to a developer? How many (100s?) of objects does a developer need to manage? Should we split sample ops state into more than one object? Those kind of issues were taking a lot of time to decide.
Furthermore, the "opt in" method in Longs Peak to move an existing application forward has its pros and cons. The model of creating another context to write Longs Peak code in is very clean. It'll work great for anyone who doesn't have a large code base that they want to move forward incrementally. I suspect that that is most of the developers that are active in this forum. However, there are a class of developers for which this would have been a, potentially very large, burden. This clearly is a controversial topic, and has its share of proponents and opponents.
While we were discussing this, the clock didn't stop ticking. The OpenGL API *has to* provide access to the latest graphics hardware features. OpenGL wasn't doing that anymore in a timely manner. OpenGL was behind in features. All graphics hardware vendors have been shipping hardware with many more features available than OpenGL was exposing. Yes, vendor specific extensions were and are available to fill the gap, but that is not the same as having a core API including those new features. An API that does not expose hardware capabilities is a dead API.
Thus, prioritization was needed, and we made several decisons.
1) We set a goal of exposing hardware functionality of the latest generations of hardware by this Siggraph. Hence, the OpenGL 3.0 and GLSL 1.30 API you guys all seem to love ;\)
2) We decided on a formal mechanism to remove functionality from the API. We fully realize that the existing API has been around for a long time, has cruft and is inconsistent with its treatment of objects (how many object models are in the OpenGL 3.0 spec? You count). In its shortest form, removing functionality is a two-step process. First, functionality will be marked "deprecated" in the specification. A long list of functionality is already marked deprecated in the OpenGL 3.0 spec. Second, a future revision of the core spec will actually remove the deprecated functionality. After that, the ARB has options. It can decide to do a third step, and fold some of the removed functionality into a profile. Profiles are optional to implement (more below) and its functionality might still be very important to a sub-set of the OpenGL market. Note that we also decided that new functionality does not have to, and will likely not work with, deprecated functionality. That will make the spec easier to write, read and understand, and drivers easier to implement.
3) We decided to provide a way to create a forward-compatible context. That is an OpenGL 3.0 context with all deprecated features removed. Giving you, as a developer, a preview of what a next version of OpenGL might look like. Drivers can take advantage of this, and might be able to optimize certain code paths in the forward-compatible context only. This is described in the WGL_ARB_create_context extension spec.
4) We decided to have a formal way of defining profiles. During the Longs Peak design phase, we ran into disagreement over what features to remove from the API. Longs Peak removed quite a lot of features as you might remember. Not coincidentally, most of those features are marked deprecated in OpenGL 3.0. The disagreements happened because of different market needs. For some markets a feature is essential,