filtering aa and scaling

[2008 IQ is unacceptable]

What's the difference between bicubic and bilinear?

I know these are noobish questions, but I've always wondered what exactly bilinear scaling and bicubic scaling is, and if they apply to anything other than scaling.

I remember someone here told me that the frame buffer is bilinear filtered with aa.

Could you trilinear filter the frame buffer, or is that not technically possible?

Finally, if it's possible, how would you design a gpu architecture to have an aa mode that's 100% compatible and done thru hardware (and does edging with a non-ordered grid pattern and does AA alpha tested textures) rather than shaders?

CFAA is all done in shaders, right? What would it take for hardware edge detect aa and transparency ss? Could it technically be done completely by the ROPs? Would the depth/stencil units have to do any extra work for 100% compatible hw edaa+trss?

 

[BRiT]

Here's some links for you to read:

http://www.codinghorror.com/blog/archives/000367.html

http://en.wikipedia.org/wiki/Bicubic_interpolation

http://en.wikipedia.org/wiki/Bilinear_interpolation

http://en.wikipedia.org/wiki/Image_scaling

 

[corysama]

Here's a very important (and fun) paper you need to read in order to understand filtering.
ftp://ftp.alvyray.com/Acrobat/6_Pixel.pdf

Bilinear interpolation is linear interpolation of a 2D signal. Trilinear interpolation is linear interpolation of a 3D signal. Mipmapped textures are a strange sort of 3D signal. The only example I can think of of a trilinearly interpolated frame buffer would be playing a low framerate video at a high framerate by displaying interpolated frames that are a blend of two sample frames.
BTW: http://en.wikipedia.org/wiki/Trilinear_interpolation

How are linear and cublic sampling different? It's easier to explain how they are related. The math to linearly interpolate to x amount between samples a and b goes like this:
linear(a,b,x) = a + x*(b-a)
Note that when x=0, the result is a. When x=1, the result is b. Between 0 and 1 there is a linear transition.

Quadratic interpolation improves quality by utilizing 3 samples instead of 2. It does so by linearly interpolating between 2 adjacent linear interpolations.
quadratic(a,b,c,x) = linear(linear(a,b,x), linear(b,c,x), x)

Cubic goes one step further and quadratically interpolates between 3 adjacent linear interpolations. This requires 4 samples.
cublic(a,b,c,d,x) = quadratic(linear(a,b,x), linear(b,c,x), linear(c,d,x), x)
There's a nice diagram of the process at the bottom of this page
http://en.wikipedia.org/wiki/De_Casteljau's_algorithm

It's not too hard to have ROPs with customizable sample locations and weights. I think some high-end SGIs had that a long time ago. Depth buffer edge detection would be a lot harder. Matching the capablities of shaders pretty much requires shaders.

I don't think antialiasing works the way you think it works. I suggest that you do some research into the mechanics of supersample and multisample antialiasing. I'd explain it, but I've already typed far too much tonight already.

 

[Moloch]

So you're asking basic 3d questions after you go on a senseless tirade against IQ in games??
Seems to me it would be most beneficial to have atleast basic understanding of 3d games before going on and on about a subject you clearly know very little about.
But that's just me