Slashdot Mirror
ATI & Nvidia Duke It Out In New Gaming War
geek_on_a_stick writes "I found this PC World article about ATI and Nvidia battling it out over paper specs on their graphics cards. Apparently ATI's next board will support pixel shader 1.4, while Nvidia's GeForce3 will only go up to ps 1.3. The bigger issue is that developers will have to choose which board they want to develop games for, or, write the code twice--one set for each board. Does this mean that future games will be hardware specific?"
Hell, Half Life and Doom are barely distinguishable from each other if your beer-goggles are thick enough. And it doesn't matter if the frame-rate slows down thru lack of processing power - your reactions are already terrible from the booze.
Yet again, beer is the cause of, and solution to one of life's problems (thanks to Homer for the [slightly paraphrased] quote).
>Write for the lowest denominator
hmm, but it seems like game developers don't do that. There is a segment of gamers that are attracted to the newest hardware _because_ it has the latest features, and they then want to buy a game that uses that feature they just paid a $$$ premium for. Totally wrong priorities, but it seems to happen.
Sure, write your game for the best compatibility across different hardware, but then you run the risk that PC Gamer magazine won't drool all over themselves in their review because the reviewer ran your demo on his rig with a GeForce XXI, but your game didn't have the latest 'cyclops, semi-transparent, half-inverse bump/pixel grinding' feature.
A 14-year old reading pcgamer has no idea what this feature really does for him, but he knows that dad is getting him a GeForce XXI for xmas, so this game isn't going to be on his santa list.
There is much cruelty in the universe, John.
Yeah, we seem to have the tour map.
Now the hardware industry has moved away from that, instead giving us free drivers for windows. Which not only are crappy in their first release, but are also useless on other platforms which the vendor decides not to support.
Bring hardware standards back, and MS will lose much of the power it's able to leverage through the high degreee of hardware support their system provides. I for one would sacrifice a little technological progress for the ability to have things work together as expected out of the box.
Ñ'
There seems to be a large amount of confusion as to what this means, and some people seem to be jumping off the deep end (as usual), so here's an attempt to clear up some of the issues.
(PS = Pixel Shader in the following points)
Hope this makes things clearer.
Pixel/Vertex shaders are an attempt to provide developers with low-level access while still maintaining the abstraction needed to support multiple sets of hardware.
To be honest, compared to the issues of shader program proliferation due to the number/type of lights you have in a scene etc., this isn't that big a deal. You might as well complain that writing a PS that uses PS1.3 means that you're 'choosing' GeForce 3 over all the existing cards that don't support PS1.3. Or that when bump mapping was added to DX and you used it, you were choosing the cards that did bump mapping over those that didn't.
DirectX is supposed to let you know the capability set of the gfx card, and allow you to use those capabilities in a standard way. The pixel shader mechanism is just another example of this at work.
As ever with games development, you aim as high as you can, and scale back (within reason) when the user's hardware can't cope with whatever you're doing.
Trust me, this is not news for games developers :-)
Tim
Every time I get a game, there's a short list of graphics devices supported on the box. I always hear about the development of this or that game, in terms of specific card features.
Heck, I even remember Carmack talking on Slashdot about things like "Nvidia's OpenGL extensions" and other features of specific cards that he was having to take advantage of.
Yeah, the new wiz-bang game will probably be able to limp-along on whatever you've got, but likely will only be optimized for a few special cards.
The video-card industry has gotten really awful. I hope that someone pulls it back in line and we get back on a standards track where card manufacturers contribute to the standards efforts and then work hard to make the standard interface efficient.
Its much like the choice to support AMD's 3DNOW or Intel's SIMD instructions. If you use DirectX 8 or OpenGL, the issue is usually dealt with by the graphics library and the card drivers. Some bleeding edge features are initially only supportible by writing specific code, but that is the exception.
END COMMUNICATION
That was insightful? Crikey.
OpenGL is written for a UNIX environment, DX is for a Windows environment
No. OpenGL is an API, with bindings on UNIX platforms, on the Mac, Win32, Linux, PSX2, XBox and so on. Pretty much all 3D hardware of note has an OpenGL driver.
OpenGL does NOT change very much, which has both good and bad sides, for example, this threads discusses pixel shading, which is a feature OpenGL does not natively supports.
OpenGL does change a lot. Hardware vendors are free to add functionality via extensions, something they cannot do with D3D without going through microsoft.
Also, it does support what DX8 calls pixelshading. It exposes it through a quite different interface to DX8 (see here and here), this much more closely represents what the hardware is actually doing.
Hehehe, don't be silly.
First of all, there are no pixel shaders in OpenGL. nVidia's extensions divide pixel shaders into Texture shaders, and Register Combiners. Which, basically mean, "Closer to the metal."
What does that mean? Well, Pixel Shader language is just a language. How the metal reacts is the same, if the semantics are the same.
However, *more importantly* ATI is going to *copy* nVidia's existing OpenGL extensions. That's the only way to compete - you must support existing features.
Don't believe me? They've already been doing this for years. Do a glGetString( GL_EXTENSIONS ); on any video card. Matrox, ATI, whatever. You're going to see a lot of NV_ (nVidia) specific extensions.
--
#include <malloc.h>
free(your.mind);
The Pixel Shader technology discussed here is in fact a part of DirectX8 (Direct3D) The issue isn't which API (in the general sense) but rather which version of a subset of an API.
Not being a 3D programmer, I don't know whether the claim of vast differences in code are true. Can anyone shed light on this?
Neurotic
But what's with all of these doom & gloom posts about fragmenting games for specific hardware? There's already a ton of features that may or may not be available in Direct3D or OpenGL depending upon your underlying hardware and driver. In Direct3D these are known as 'capabilities', in OpenGL they are 'extentions', in either API you can easily check for their existence.
Game developers are already doing this for features such as dot3 bumpmaping. Some boards support this feature in hardware, some don't, so your code is free to check to see if its available and use it if it is or ignore it (or fallback to some other method) if its not.
These shaders aren't really any different from that.. you write code to look at the shader version supported and either use 'new improved' shaders or 'older style shaders' depending upon the platform.
Yes, its more work for the programmer/artists to support a fallback mode, but that's the price of targetting cutting edge gaming hardware while still supporting users of older systems. It always has been and always will be.
As to the dramatic question of ATI vs NVidia, I'd say that NVidia has the early advantage due to the XBox. Considering how similar the XBOX graphics system is to the PC GeForce 3, its pretty much guaranteed that all of the major gaming engines being used to create most 'big' games these days will target GeForce3/XBOX features specifically, and features of 'other boards' (such as ATI) only as a bonus if there's enough time, or ATI lays down enough cash on a crossmarketing deal.
Of course, if Microsoft manages to flub the XBOX release to a staggering degree, all bets as to the future are off.
...is that developers shouldn't HAVE to develop for specific hardware. I don't work in the game industry specifically, but I don't see how this is necessarily good for software in general, or graphics software in particular. This doesn't give developers "more choice in the hardware they develop for" It gives them less choice, because they have to decide how to allocate limited resources on a per-platform basis. When you have a common API, you're not forced to choose in the first place. That's why hardware specific features and capabilities ought to be abstracted-out into a common API. What these guys should do is come up with a dozen or so different kinds of high-level magic (e.g. water waves, flame, smoke,bullet-holes, whatever) that they can work with their pixel and vertex shaders, lobby Microsoft to get that magic incorporated into the DirectX spec, and then supply drivers that meet those specs by sending a few pre-packaged routines to the pixel/vertex shaders, rather than have game developers worry about this stuff directly. Or am I missing something?
Oh, but you forgot the fourth option:
Say screw'em both and develop for neither, just using lowest common denominator stuff, and spend the saved time on improving the other parts of the game.
If your game cant stand on its own using that... well, maybe, just maybe, it sucks?
The differences in hardware are not that big of a problem for next generation graphics engines. The amount of features and flexibility available now necessitate using a higher level shader language as opposed to hardware specific api features. A well designed shader language can be compiled to take advantage of whatever driver features you have available, and emulate or ignore the rest.
We are currently able to target both pixel shader versions in DirectX, and hopefully soon in OpenGL. We are currently ignoring features not supported by the hardware that shader code tries to use. So rendering the shader surface on a GeForce1 will look much worse than on a full featured card, but we don't waste time emulating it.
For reference on similiar techniques check otu Proudfoot et al. 'A Real-Time Procedural Shading System for Programmable Graphics Hardware'. (Thought thats based on NVIDIA hardware, it extendable to new features as well)
I don't care about reducing the pass number.
The framebuffer is only 8 bits per channel at most, while pixel shader hardware has higher internal precision per channel, keeping the math in the chip as well as saving read-back from the framebuffer saves bandwidth AND improves quality.
True per-pixel phong shading looks nice, but then all they seem to do extra is allow you to vary some constants across the object via texture addresses
Pixel shaders enable arbitrary math on pixels, it isn't a fixed function phong equation with a few more variables added. Maybe an artist wants a sharp terminator, cel shading, a fresnel term, or wants a anisotropic reflection.
All these are performed using 4D SIMD math operations, just like they were in 1.1: Add, Subtract, Multiply, Multiply-Add, Dot Product, Lerp, and Read Texture. But texture reads can happen AFTER more complex math, before there was only a few set math ops possible during a texture read. It's all in the DX8 SDK, which anyone can download.
Well that's great, but texture upload bandwidth is can already be significant bottleneck
"texture upload?" This isn't a problem, with DX8.1 cards having 64mb of memory for texture, why would developers be uploading textures per-frame? If you are talking about texture reads by the pixel shader, this also isn't a bottleneck. Reading geometry from the AGP bus is the bottleneck.
Artists won't draw bump-maps.
Sure they will, (heck, I do) look at any x-box game, they are all over the place. They won't draw in vectors-encoded-as-colors, they'll draw height maps, which would be converted off-line into normal maps.
I don't think ATI have a PS 1.0 implementation, someone please correct me if I'm wrong
1.4 hardware can support any previous version, including DX7 fixed function blend ops.
P.S.
I design hardware for this stuff, I do know what I'm talking about.
is the level of compatibility there is. PS 1.4 is really just an extension of 1.3 -- it adds more instructions to the same basic architeture. If you write for GF3, it'll run just fine on the R200 or whatever. If you write for R200, it'll run just fine on nVidia's next part, even though it supports PS1.5. It's all back-compatible, I believe. It's sorta like the deal with two texture units vs three (GF2 vs Radeon) or single-pass quad texture with two units (GF3). Write for the lowest denominator you care to, it'll work fine on all the newer stuff.
Most of the DirectX -> OpenGL ports aren't that great. UT, for example, runs beter on Windows than on Linux. (Given that the lead programmer for the project has publicly dissed OpenGL, I'm not surprised). Plus, the ones that are there are ported are from pretty substantial companies. Besides, are you saying that more DirectX games is a *good* thing?
A deep unwavering belief is a sure sign you're missing something...
Obviously someone who has now clue how DirectX is designed! The DirectX team doesn't get led around by NVIDIA. The vast majority of the new features in DirectX get there because game developers want them. MS doesn't go into a room with NVIDIA and then send a DirectX release out. Instead, hardware vendors talk about what features they are thinking of putting in, software developers then ask for features that should be put in, and it goes back and forth until another DirectX comes out. Microsoft has some incredibly arrogant and stupid practices, but for a long time, I've had a hunch that the DirectX team wasn't part of the core MS culture. For example, they don't go to absurd lengths to make every single piece of a code a full-blown COMponent that can be remotely marshalled. DirectX's implementation of COM is so simplistic, I'm sure they got heat for it from the abstraction-obsessed Win32 guys.
A deep unwavering belief is a sure sign you're missing something...
You are boring, you know? (And moderators couldn't spot a troll even if they were standing under a bridge) We already went over this at least twice, and you are bringing out the same dried up arguments again. You still haven't said what prevents NVIDIA and ATI and the ARB from sitting at the table and coming up with an uniform API for such an extension. Last time your cried, just like know, that the "hardware" is too different. Bullshit. Direct3D is no better. You just have to decide on a freaking API and let the vendors implement that. Read elsewhere in this discussion about programmers not supporting DirectX N yet. How's that better than OpenGL's extension mechanism? It's not better. You still have to rewrite stuff. The only difference is that some companies that will remain unnamed have placed stupid patents arround interfaces, not features, interfaces and other companies have to come up and implement their own. If you want to bitch at someone, bitch at the companies that patent interfaces and stop trolling about OpenGL not supporting current technology.
I think you're thinking of OpenGL.
I've programmed both, and I find DirectX to be *much* more powerful. For example, in DirectX you can render to a texture. Unless you dig up some SGI extension, you can't do the same in OpenGL. The problem is that while the core DirectX feature set will work on any card, specific extensions won't. The reason that DirectX doesn't have the same problem is that MS actively integrates new features into the core set. Meanwhile, OpenGL hasn't changed that much since 1.1. Let me give you a concrete example. Take this pixel shader thing. NVIDIA has a pixel shader implementation, and ATI has one. On OpenGL, they are exposed through different extensions. Thus, a developer must code for both extensions. In DirectX, they just have to write to the Pixel shader API. If Matrox comes along, they support the DirectX pixel shader API, but release a matrox-specific OpenGL extension. OpenGL developers now have 3 APIs to contend with, DirectX developers still have one. Eventually, the ARB gets around to making pixel shaders a standard extension, but in the meantime, the next big feature has come. Lather, rinse, and repeat.
A deep unwavering belief is a sure sign you're missing something...
Looks like we're back to the days of yore, when you (the developer) got to choose to support a specific card (3dfx or the others that didn't survive) because there was no DirectX support... because there was no DirectX. Then you (the consumer) got the shaft if you didn't have the right card, unless the developer later came out with a binary that would support your card's features. But if it wasn't an uber-popular game, this usually didn't happen.
So why are Nvidia and ATI forcing developer to go back to the stone age of accelerated polygons? Oh that's right... Me likes pretty picture.
SGI released the reference implementation under a MPL variant type license back last year. Right along with the GLX implementation.
It's Open Source.
I am not merely a "consumer" or a "taxpayer". I am a Citizen of the State of Texas
First of all, a direct link to ATI's SmartShader tech introduction.
.plan of his if you want to read more.
I have a few disparate thoughts on this subject, but rather than scatter them throughout the messages I'll put 'em all in one place.
ATI are attacking what is possibly the weakest part IMHO of DirectX 8 - the pixel shaders. Pixel shaders operate on the per-fragment level, rather than on the per-vertex level vertex shaders which were actually Quite Good. The problem with Pixel Shaders 1.1 is that, to paraphrase John Carmack, "You can't just do a bunch of math and then an arbitary texture read" - the instruction set seemed to be tailored towards enabling a few (cool) effects, rather than supplying a generic framework. Again, to quote Carmack, "It's like EMBM writ large". Read a recent
If you read the ATI paper, they don't really tell you what they've done - just a lot of promises, and a couple of "more flexibles!", "more better!" kind of lip-service. I don't care about reducing the pass number. Hardware is getting faster. True per-pixel phong shading looks nice, but then all they seem to do extra is allow you to vary some constants across the object via texture addresses. Well that's great, but texture upload bandwidth is can already be significant bottleneck, so I don't know for sure that artists are gonna be able to create and leverage a separate ka, ks etc map for each material. (I did enjoy their attempts to make Phong's equation look as difficult as possible)
True bump-mapping? NVidia do a very good looking bump-map. Adding multiple bump-maps is very definitely an obvious evolutionary step, but again, producing the tools for these things is going to be key. Artists won't draw bump-maps.
Their hair model looks like crap. Sorry, but even as a simple anisotropic reflection example (which again NVidia have had papers on for ages) it looks like ass. Procedural textures, though, are cool - these will save on texture uploads if they're done right.
What does worry me is that the whole idea of getting NVidia and Microsoft together to do Pixel Shaders and Vertex Shaders is so that the instruction set would be universally adopted. Unfortunately, ATI seem to have said "Sod that, we'll wait for Pixel Shader 1.4 (or whatever) and support that." I hope that doesn't come back to bite them. DirectX 8.0 games are few and far between at the moment, so when they do come out there'll be a period when only Nvidia's cards will really cut it (I don't think ATI have a PS 1.0 implementation, someone please correct me if I'm wrong) - will skipping a generation hurt ATI, given that they're losing the OEM market share as well?
I dunno, this just seems like a lot of hype, little content.
Henry
i don't do sigs. oops.
The Pixel Shader technology will be backwards compatable as far as the DirectX 8.0 API is concerned. Imagine that. Microsoft using an API to bring software developers together across various hardware choices.
Sadly the situation is not unified in OpenGL yet, with both Nvidia and ATI providing their own separate extensions for accessing pixel shaders. One can only hope that its not too long before we can get an ARB-approved extension that covers the capabilities of both cards.
Of course, since it will be quite a while before games publishers can rely on people having a GeForce3 or Radeon2, I expect pixel shaders will only be used for optional flash for quite some time. If people are doing bump mapping and phong shading and so on using them, they'll certainly have the option to run in a slightly less attractive mode for those with lamer hardware.
Who would buy an ATI board? Well, I would. Not to fan the flames, but...
I've owned a few video boards over the years, and have been constantly looking for a board that does both good 2D and 3D, and up until now, I haven't really found it. My Matrox Millenium (from about four years ago) did excellent 2D, no 3D. My Voodoo Rush had decent 3D for it's time, but the 2D sucked (blurry image, and this was without a passthrough cable). That got replaced (after switching back to the Matrox) with an nVidia TNT Ultra. The 3D was pretty good, but the 2D was a bit blurry (I dumped the TNT when I spoke with nVidia and confirmed that they were not producing Open Source Linux drivers - I don't like liars too much). So, the TNT got replaced by a Matrox G400Max Dualhead - excellent 2D, the 3D was lacking somewhat.
Just this weekend I purchased an ATI Radeon All-In-Wonder for $250. An excellent deal, since the 2D is nice and crisp, and the 3D rocks (for my purposes anyway). And, in 32-bit mode, it almost equals the GeForce 2 in performance.
Plus, this board has excellent multimedia. I love the TV tuner, it's so much better than the Hauppauge I used it to replace, plus I can hook up all sorts of video input devices and record from them. Excellent on the fly MPEG compression. And of course, we can't forget the hardware DVD playback, which is outstanding.
Also, like other people have said, let's not forget that the GeForce cards are still quite expensive.
A friend of mine was telling me three years ago that ATI made great cards, and I scoffed at him. Looks like I owe him an apology.
So, in conclusion, who would buy an ATI? How about somebody who wants a full-featured card that gives outstanding image quality. If you want pure frames per second, then buy your GeForce with it's blurry, dim images, since they screw around with the palettes and overclock the chips to get those numbers that hardcore gamers seem to like so much.
-- Joe
The Pixel Shader technology will be backwards compatable as far as the DirectX 8.0 API is concerned. Imagine that. Microsoft using an API to bring software developers together across various hardware choices. Now only if they could get Win32 cleaned up and a decent kernel, then I'd THINK about purchasing that OS. Although I'm not saying that there won't be card specific code, but as far as Pixel shader tech goes, as long as the drivers are DX 8 compatable, there's no problem with code for one card not working on the other. Besides, most systems sold in the last year have 810/810e/815E chipsets and stuck with those old i740 Starfighter chips.
Non impediti ratione cogitationus.
hmmm, first let me say I'm getting a GeForce three rather than an ATI Radeon for my new computer, so I'm not really biased.....ATI Radeon DDR 64MB, $200........Geforce 3 DDR 64MB, $400........light-speed memory architecture, priceless. ATI isn't over-priced, they are very reasonably priced, if I wasn't a total performance junky I'd be getting a Radeon instead of a GeForce 3 because the Geforce 3 is definately overpriced.
"
This story actually gives me a chance to bitch about OpenGL! None of these new features are a part of the standard OpenGL. "Extensions! Extensions!" you shout. However, due to the differences between hardware, you'll end up with ATI and NVIDIA versions of the same extensions, since the ARB won't touch such new/untested features. This makes sense in the pro segment, where hardware is slow to evolve, but in the consumer segment, it will make the API seem antiquated. Plus, the extension mechanism isn't even suited to such uses anyway, since it was meant to expose features, not radically different methods of rendering. And yes, these are radically different. Part of the reason that the GeForce3 has 57 million transistors is that it has to have a standard geometry engine for DirectX 7 and a new vertex shader-based geometry engine.
In the long run, this will make OpenGL unpopular with game developers. Sure guys like Carmack and afford to suck it in and develop to all the extensions, but for a small development house that wants to make an impressive game, they'll go with DirectX to save themselves the development costs. And when they do, there goes the possibility of a native Linux port.
Now there are two solutions to this. First, the ARB could get off their asses and start integrating extensions. This could be problemetic for the pro segment, which wants a stable API. On the other hand, the ARB could fork OpenGL into a pro and a consumer version, but that results in two incompatible APIs. I think Microsoft is doing the right thing by supporting the latest featuers (in essense, baiting all the hardware manufactuers to integrate these features) but it *does* make DirectX unsuitable for pro use.
A deep unwavering belief is a sure sign you're missing something...
HehE. The two libraries you named are proprietary (3DFX's Glide and M$'s DirectX)... the standard is OpenGL.
Does this mean that future games will be hardware specific?
Well, no. Game developers do prefer the state of the art, but common sense dictates that you target something that is exists and is popular.Comparisons to browser market shares are appropriate here: When Internet Explorer became the norm, web sites tended to take advantage of IE's superior DHTML and DOM support, but developers have mostly strived to make pages backwards-compatible with Netscape and other less capable browsers. After Mozilla caught up, most web sites still aren't targeting it specifically.
Keep in mind that, according to the article, the board does not currently exist. One's desire to write custom code for a nonexistent board is contingent on several factors, such as the manufacturer's present and potential future market share.
Case in point: Developers used to target Glide, 3Dfx' low-level rendering API. Games these days don't bother: 3Dfx has DirectX support, the effort to squeeze a few extra FPS from writing "straight to the metal" usually isn't worth the time and money, and most importantly, 3Dfx is dead. Its user base is dwindling, and there is no incentive to use the (generally) hardware-specific Glide over the generic DirectX.
As for the development effort: As a former game developer and Direct3D user, I agree with the claim that when targeting both shaders, "they'll have to write more code". A few hundred lines, perhaps, for detecting and using the two extra texture shaders per pass. It's not like it's a new, different API.
I'm surprised at the lack of comments about platform support for these new features.
If you own a GeForce3 *today*, you can access all of the hardware's features on Linux, Windows and Mac through OpenGL.
I don't know about ATI's Mac support, but under Linux the Radeon drivers still don't support T&L, cube maps, 3D textures or all three texture units. The card has been available for well over a year, but the driver only enables Rage128-level features. How long do you think it's going to take for the pixel and vertex shader capabilities to make it into the Linux drivers? And what about the Mac?
I've been extremely impressed by the balanced approach NVIDIA has been taking: they do a great deal of work on D3D 8 with Microsoft, but they simultaneously create OpenGL extensions for interesting hardware features, allowing Windows developers to target OpenGL, and also allowing alternate plaforms to access the new features. Their OpenGL support surpasses any other consumer grade hardware manufacturer's, and they offer better cross plaform support than any graphics company.
The safest choice any game developer can make is NVIDIA.
-Mark
"Good people drink good beer"
I think the poster you're replying to was referring to the fact that nVidia released closed-source drivers for X. Without the specs on hand, an independent group cannot develop an open source driver.
The problem with closed source drivers is that they're always going to suck. The kernel licensing makes it possible, but the kernel module interface is set up to benefit modules that are compiled against the actual source tree. nVidia's hardware accelerated drivers crash my machine without flaw. I had to downgrade to a prior version to get it to sort of work (the helpful nVidia developers actually told me that I had to do this, to their credit). Even then it crashes my X periodically.
If they had written an open source driver, all of the bugs would have certainly been fixed by now, and if they had just released the specs, they wouldn't have had to develop the driver at all.
And before you go and defend poor nVidia's property rights, let me save you the trouble. nVidia wanted to release an open source driver. They full well understand the benefits, being a company made up of the best engineers in the industry. Unfortunately, part of the driver code was contributed by a third-party who refuses to let them open source it. The end.
My next card, sadly, unfortunately, oh god I wish it could be, won't be an nVidia.
You mean like when Netscape and IE were competing? In case you haven't noticed, HTML rendering between the two browsers haven't exactly meshed.
Where are we going and why am I in this handbasket?
I'm one of the developers of next version of the Genesis3D game engine. We ran into this problem of what do we support on an engine that is to push the latest cards to the limits.
The simple answer was to write the common code in the main part of the engine then write multiple drivers for the engine that would use different features on different cards. This way we could push both cards and optimize the code for each card to get the best performance. Of course this is no easy task either.
This is a pain but if you wish to push what each card can do, you have to write code for each individual card or maker of the cards (IE a nVidia driver and an ATI driver then a 3rd driver for everything else that the other 2 don't optimize and run on).
The standard lighting model in DOOM, with all features enabled, but no custom shaders, takes five passes on a GF1/2 or Radeon, either two or three passes on a GF3, and should be possible in a clear + single pass on ATI's new part.
It is still unclear how the total performance picture will look.
Lots of pixels are still rendered with no textures at all (stencil shadows), or only a single texture (blended effects), so the pass advantage will only show up on some subset of all the drawing.
If ATI doesn't do as good of a job with the memory interface, or doesn't get the clock rate up as high as NVidia, they will still lose.
The pixel operations are a step more flexible than Nvidia's current options, but it is still clearly not where things are going to be going soon in terms of generality.
Developers are just going to need to sweat out the diversity or go for a least common denominator for the next couple years.
I fully expect the next generation engine after the current DOOM engine will be targeted at the properly general purpose graphics processors that I have been pushing towards over the last several years.
Hardware vendors are sort of reticent to give up being able to "out feature" the opposition, but the arguments for the final flexibility steps are too strong to ignore.
John Carmack
I think the answer to that question is to rate just how flexible the current API's can be. The two contenders (and please, let's try not to make MORE!) are OpenGL and DirectX. Nvidia has ressurected the venerable Amiga's idea for a fully programmable graphics processor, and I presume that ATI's post-Raedon chip will be similar.
So, which API allows one to most easily get at the GPU's coding power? How many hooks does the high level api have into the gpu's engine, and can the gpu get data from the api on the fly?
If anyone out there has worked with them, I'd be curious to hear what's present or lacking from the standards, and if it's feasable to try and write GPU level code abstractly.
Riiight. You're just used to coding for Windows- it's easier for you because you're inured in that style of coding.
I am not merely a "consumer" or a "taxpayer". I am a Citizen of the State of Texas
Informative? What's up with you moderators today?
OpenGL is an open standard, but the source code isn't open--there isn't even any source code!
http://oss.sgi.com/projects/ogl-sample/
Game development companies will write code to the lowest common denominator that allows them to turn their projected profit.
If this means using ASCII on a VT100, that's what they'll do.
All opinions presented here aren't mine.
Say what? NVidia's cards have always rocked (except the ZX chipset admittedly), I agree. But NVidia provide a level of community support *far and away* better than ATI. NVidia host conferences for grad students and their professors. They have developer conferences in many different countries. Matt and Cass from NVidia hang out on opengl.org's discussion forums and help everyone out (newbies, old hands, the lot). The developer documentation is sublime - and everyone can get at it. Plus their drivers *just work* 9 times out of 10.
I could care less about driver specs. The 3dfx ones are around if I want to see how modern-ish graphics cards are set up. And their drivers are such good quality, I can see why they don't want mutations springing up all over the web. I certainly don't have a problem with such a pleasant company to work with wanting to hold on to a few secrets.
Henry
i don't do sigs. oops.
If so, it won't be the first time; remember the days of 3dfx? Original Unreal would only run on Glide hardware acceleration; if you didn't have a 3dfx card, you were forced to run it in software. Of course, this didn't sit well with the growing NVidia user base who consistently pointed out that Quake 2 and Half-Life both rendered on anything running OpenGL (including 3dfx cards; remember those mini-driver days?), and OpenGL and Direct3D renderers were finally introduced in a patch. That's about when 3dfx started to go down the toilet; delaying product releases and missing features (32-bit color and large texture support being two of the most blatant omissions) eventually tainted the 3dfx brand to the point of extinction.
Since then, 3D gaming has been a less lopsided world. Linux gaming was taken seriously. Standardised APIs that could run on almost anything were the rule; if it wasn't OpenGL, it would at least be Direct3D. Then the GL extensions war heated up, with NVidia developing proprietary extensions that would work only on their cards. But this wasn't a problem; you could still run OpenGL games on anything that could run OpenGL; you'd just be missing out on a few features that would only slightly enhance the scenery.
Leave it to Microsoft to screw it all up with DirectX 8. They suddenly started talking about pixel shaders and other new ideas. John Carmack has already described the shortfalls and antics of DX8. And now 3D programmers will have to program for multiple rendering platforms, but at least you can still run it with anything.
Sure, this entire disagreement between ATI and NVidia is bad for the 3D industry, but things could be worse. A LOT worse.
"Ancillary does not mean you get to rule the world." --U.S. Circuit Judge Harry Edwards, speaking to the FCC's lawyer
How is this meant to be good for developers, or consumers? Developers now have three options:
This is also terrible for the consumer. Sorry, but that new card you just spend a small fortune on doesn't support the pixel shader version the game you want uses. Oh well, you'll just have to upgrade to the next card, when it comes out, hope that's okay. But don't worry, it will have lots of new features too (which no-one elses card will support).
DirectX has full documentation freely available, also DX doesnt only support accelerated graphics but the whole range in output and input devices such as joysticks, sound etc etc.
OpenGL is written for a UNIX environment, DX is for a Windows environment. And yes, opengl is opensource and very easy to learn, but still it has alot of drawbacks, one of them being those dinosaurs that runs it.
OpenGL does NOT change very much, which has both good and bad sides, for example, this threads discusses pixel shading, which is a feature OpenGL does not natively supports. I do not know how hard this is to implement in DX, but I figure that since they are even talking about it and not just dismissing it as some "toy" like the OpenGL-board seems todo..
This is good for hardware because ATI and NVidia will continue to push the envelope, developing more and more advanced graphics boards. Features will creep from one end to the other, just staggered a generation.
This is good for software because developers will have more choice in the hardware that they develop for. ATI doesn't support super-duper-gooified blob rendering? Ah, NVidia does in their new Geforce5. No worries, ATI will have to support it in their next generation boards.
A bipolar competition is ALWAYS good for the consumer.
Execute? [Y/N] _
You mean like Coke/Pepsi, where they essentially agreed to divide the market, and either acquired everyone else, or drove them out of business. Then what pretense of competition left is according to their own "gentlemen's rules". They probably insist that they are competing fiercely, but I might argue that it's more like a fencing match with masks, padding, and the little balls on the tips of the foils.
Imagine a sort of RIAA for soft drinks.
The living have better things to do than to continue hating the dead.