Re: Tesselating complex figures with Render

On Fri, 2002-05-10 at 22:38, Keith Packard wrote:
> When the polygon vertices have non-integer coordinates, this places a seam 
> along a sub-pixel boundary.  Pixels which are completely covered by the 
> polygon are rendered by two separate trapezoids, each covering a portion 
> of the pixels and together precisely filling the pixels.
> 
> Render has an operation which will cause the right result on the screen, 
> the DisjointOver operator ensures that the pixel will be fully painted 
> with the polygon.  However, DisjointOver requires a destination alpha 
> channel to track the pixel coverage.

Does this allow the framebuffer alpha channel to be used for subsequent
composition (for example, hardware which blends graphics with an
underlying video surface)?  Or would you need two destination alpha
channels to support that correctly (one for coverage and one for
translucency)?  What if, for example, the traps themselves are
translucent and use an alpha value to represent translucency rather than
coverage.  It seems to me that the blending operator needed to make an
anti-aliased common edge join correctly will be different from the one
needed to do translucency, and you can't get correct results by trying
to overload one alpha value for both purposes (at least not in one
pass).

OpenGL has always had the problem that using GL_POLYGON_SMOOTH has never
resulted in clean (seamless) seams between adjacent triangles in a
tesselated polygon.  I presume the Render proposal is specified to make
sure that works properly in this case.

The other way of working this is to simply only perform AA on trapezoid
edges which are not adjoining other traps in the same polygon.  If you
don't have AA on a common edge and the two traps have the same vertices
along that edge then you'll get correct results without a destination
alpha.  The tricky part is getting it right for traps of adjacent
polygons which share a common edge which shouldn't have a seam.

> Text painting already does this by adding the glyphs together in a 
> temporary buffer and then applying the result as a mask to the 
> destination; that's essentially the desired effect for polygons.

Does this mean a two-pass composition?  Composite the traps together,
then composite the result with the framebuffer?

	J