[Gzz-commits] manuscripts/AGPU fillets.txt irregu.txt

[Tuomas J. Lukka]

CVSROOT:        /cvsroot/gzz
Module name:    manuscripts
Changes by:     Tuomas J. Lukka <address@hidden>        03/04/07 09:11:12

Modified files:
        AGPU           : fillets.txt irregu.txt 

Log message:
        More...

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/gzz/manuscripts/AGPU/fillets.txt.diff?tr1=1.2&tr2=1.3&r1=text&r2=text
http://savannah.gnu.org/cgi-bin/viewcvs/gzz/manuscripts/AGPU/irregu.txt.diff?tr1=1.2&tr2=1.3&r1=text&r2=text

Patches:
Index: manuscripts/AGPU/fillets.txt
diff -u manuscripts/AGPU/fillets.txt:1.2 manuscripts/AGPU/fillets.txt:1.3
--- manuscripts/AGPU/fillets.txt:1.2    Mon Apr  7 07:05:41 2003
+++ manuscripts/AGPU/fillets.txt        Mon Apr  7 09:11:12 2003
@@ -6,3 +6,33 @@
 Achieving a specific rendering goal efficiently, several different methods.
 
 All techniques pretty familiar, but the application is novel.
+
+-------
+
+Rendering fillets
+
+Fillets (Lukka, Kujala and Niemelä, Information Visualization'02
+conference, reprint available on request) are graphical technique for
+enhancing the rendering of graphs - generally, objects on screen connected
+by lines. Fillets, in the original meaning of the term in plastic 
+or metal casting (A. Rockwood, chapter 6 (Blending), in Jules Bloomenthal, ed,
+"Introduction to Implicit Surfaces", Morgan Kaufmann 1997),
+mean the fillings used for sharp crevices to avoid breaking of the finished
+object at the sharp corners.  Our use of fillets here is analogical: 
+we use fillets to avoid the viewer's perception breaking the object and
+the line into separate pieces.
+
+Drawing fillets is difficult
+
+
+
+From the GPU perspective, the techniques presented
+
+None of the techniques presented are particularly novel, but applying
+them to the novel problem (rendering fillets) allows a goal-oriented
+presentation of these basic techniques.  Along with our other proposal
+(Rendering and animating torn 2 1/2 D viewports efficiently) we feel that
+this proposal covers the area of 2 1/2 D rendering on the GPU fairly
+comprehensively; this proposal is more concerned on vertex processing
+and the other on fragment processing.
+
Index: manuscripts/AGPU/irregu.txt
diff -u manuscripts/AGPU/irregu.txt:1.2 manuscripts/AGPU/irregu.txt:1.3
--- manuscripts/AGPU/irregu.txt:1.2     Mon Apr  7 07:05:41 2003
+++ manuscripts/AGPU/irregu.txt Mon Apr  7 09:11:12 2003
@@ -1,7 +1,73 @@
+- 2 1/2 D !!!
 
-Irregular edges as viewports
+------
 
-Special type of animation requires texel processing flexibility
+Rendering and animating torn 2 1/2 D viewports efficiently
+==================================================
+
+In our as-yet-unpublished manuscript "Tearing instead of rectangular
+clipping/framing viewports in user interfaces" (preprint available on
+request) we present the use of break lines[Fig.1] as an alternative
+to the ubiquitous rectangular frames in user interfaces.  In a sense,
+we figuratively tear a piece off the large canvas instead of presenting
+a framed view (window) to it[Fig.2].
+
+In order to maintain the illusion, the animation has to be appropriate:
+having the shape of the jagged edge remain while the viewport moves over
+the canvas would still *feel* like a window. The shape of the jagged
+edge must be tied to the location on the background[Fig.3].
+
+We show how the GPU can be used to accomplish this - this is the easy
+part and we can even do this on unextended OpenGL 1.3 (XXX jvk!),
+although the flexibility of the NV10 architecture allows us to obtain
+some more accuracy and improved shapes. The technique is simple:
+we tie the texture coordinates to the canvas inside (two different
+ways to do this for different appearance in the results - completely
+connected or with pieces of the shape separating from the edge) and
+draw smoothly interpolated polygons with a different color inside and
+outside of the viewport. The pixel pipeline is coaxed to combining the
+interpolated value and the texture value into a single alpha value.
+Because the alpha test is performed prior to the stencil test, we can
+create the shape by rejecting fragments with the alpha test and drawing
+the remaining shape into the stencil buffer.  Once the shape is in the
+stencil buffer, it can be used as a viewport for any graphics.
+
+The more difficult part to do efficiently is the rendering of the black
+non-photorealistic edge of the viewport. The problem is that we need the
+edge to be of a constant thickness so just offsetting it in one direction
+will not suffice. The old trick is of course drawing the original shape
+several times, slightly shifted, but this is relatively inefficient.
+We present several approximative algorithms which are able to draw the
+required shape in one pass. The algorithms require various levels of
+hardware flexibility - ranging from dot products to NV25 offset textures.
+(and if we obtain our NV30 and NV34 cards in time, we'll also discuss
+the possibilities there).
+
+The core of this proposal is in the original use of texture coordinates
+to obtain the connected shape, the generation of the shapes from the
+interpolated color and alpha, and the rendering of the edges of constant
+thicnkess.  Together, the generation of the shapes and drawing of the edge
+explain several details of the capabilities of the fragment pipelines
+of different levels of hardware and how to accomplish better results in
+this task using them.
+
+The line algorithms are immediately applicable by anyone wishing to draw an
+edge to any shape that is obtained programmatically from textures.
+
+Our current implementations are OpenGL1.3 with NV extensions but we
+can easily rewrite them using Cg.
+
+--- Figures
+
+Fig.1 shows break lines in their conventional context: break lines
+are the freehand lines implying that the object extends outside the
+depicted region.
+
+Fig.2 shows a screenshot from our BuoyOING user interface.
+
+Fig.3 shows how the shape of a torn frame changes when the frame moves
+(the canvas stays still in this figure). The shape of the edge is tied
+to its location, making the movement feel more like "a piece of paper
+that has magically been torn from a slightly different location from
+where it was a moment ago". Obtaining
 
-Drawing a shape obtained from texture and dot product manipulation
-into stencil buffer.