[Gzz-commits] gzz/Documentation/Manuscripts/Irregu irregu.tex

[Tuomas J. Lukka]

CVSROOT:        /cvsroot/gzz
Module name:    gzz
Changes by:     Tuomas J. Lukka <address@hidden>        02/11/30 05:09:19

Modified files:
        Documentation/Manuscripts/Irregu: irregu.tex 

Log message:
        HW

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/gzz/gzz/Documentation/Manuscripts/Irregu/irregu.tex.diff?tr1=1.106&tr2=1.107&r1=text&r2=text

Patches:
Index: gzz/Documentation/Manuscripts/Irregu/irregu.tex
diff -u gzz/Documentation/Manuscripts/Irregu/irregu.tex:1.106 
gzz/Documentation/Manuscripts/Irregu/irregu.tex:1.107
--- gzz/Documentation/Manuscripts/Irregu/irregu.tex:1.106       Sat Nov 30 
04:40:12 2002
+++ gzz/Documentation/Manuscripts/Irregu/irregu.tex     Sat Nov 30 05:09:19 2002
@@ -438,9 +438,9 @@
 The most obvious choice is to use an offset: if $a(\p)$ is the 
 indicator function for the shape $A$, i.e. 1 if $\p$ is inside $A$ and
 0 otherwise, then
-$$
+\begin{equation} \label{eqoffset}
     b(\p) = a(\p + f(\p)).
-$$
+\end{equation}
 This is the way Perlin\cite{perlin-noise-intro} create marble out of
 lines.
 
@@ -449,11 +449,11 @@
 A different approach is to displace the border of $A$: if $\afunc(t)$ is
 the parametrized curve of the border of the original shape,
 then
-$$
+\[
     \bfunc(t) = \afunc(t) + f(\afunc(t)).
-$$
+\]
 This technique is commonly called displacement mapping.
-There are variations to this such as displacing along the border.
+There are variations to this such as displacing along the normal direction.
 
 The important point w.r.t.~both of of these common techniques 
 is that the displacement depends on location in {\em canvas} coordinates,
@@ -536,47 +536,53 @@
 
 We shall concentrate on OpenGL and NVIDIA extensions (due
 to their availability in the Linux environment), but 
-the feature sets of other APIs and manufacturers
+the feature sets of other 
+manufacturers
+and 
+proprietary APIs 
 are quite similar.
 
-OpenGL allows non-rectangular viewports through the stencil buffer
+OpenGL allows non-rectangular viewports through the stencil buffer,
+which can be used to create the stencil in a first pass
+by just drawing into the pixels and then in the second pass
+set to mask only those pixels to be allowed to be drawn that were
+touched in the first pass. 
 
 There are two basic alternatives for drawing the shape: either
 by using geometry to draw the jagged edge segment by segment,
 or by using a texture to draw a longer stretch at one time.
 We have chosen the latter approach as the more likely one to
 yield an acceptable performance. Also, it is easier to avoid
-aliasing artifacts in the texture approach..
-
-% This type of mapping is implemented in modern
-% texture shading hardware:
-% the image of the undistorted shape can be stored in a texture and accessed
-% with texture coordinates offset by (read from) another texture.
-% This is called an offset (dependent) texture access.
-
-The forward function cannot be efficiently implemented on pixel level,
-because each pixel may depend on multiple values of the function.
-The edge of the shape could be displaced on vertex level, 
-but that is likely to not yield good performance if the shape has fine detail.
-Furthermore, intersections in the edge may cause additional problems.
-If the function is bijection, so as to avoid any intersections, we
-can just as well use the inverse mapping.
-
+aliasing artifacts in the texture approach.
 This approach, generating shape through texture, is similar to
 the one used by Perlin in \cite{perlin-hypertexture} for synthesizing
 solid shapes.
 
-In the following, we shall concentrate on drawing one rectangular section
-of the envelope, in the unit square, with $y=0$ inside the tear-out,
-$y=1$ outside the tear-out, and $x$ along the length of the envelope.
-It assumed that the canvas location $E(x,y)$ 
-depends linearly on the parameters $x$ and $y$
-inside the section of the envelope.
-Furthermore, without loss of generality, we assume that $E(x,y) = (x,y)$.
-At the end of this section, we consider how to use the rectangular 
-pieces to create a complete tear-out shape.
+% The forward function cannot be efficiently implemented on pixel level,
+% because each pixel may depend on multiple values of the function.
+% The edge of the shape could be displaced on vertex level, 
+% but that is likely to not yield good performance if the shape has fine 
detail.
+% Furthermore, intersections in the edge may cause additional problems.
+% If the function is bijection, so as to avoid any intersections, we
+% can just as well use the inverse mapping.
+
+% In the following, we shall concentrate on drawing one rectangular section
+% of the envelope, in the unit square, with $y=0$ inside the tear-out,
+% $y=1$ outside the tear-out, and $x$ along the length of the envelope.
+% It assumed that the canvas location $E(x,y)$ 
+% depends linearly on the parameters $x$ and $y$
+% inside the section of the envelope.
+% Furthermore, without loss of generality, we assume that $E(x,y) = (x,y)$.
+% At the end of this section, we consider how to use the rectangular 
+% pieces to create a complete tear-out shape.
 
 \subsection{Drawing the shape}
+
+The type of offsetting in Eq.(\ref{eqoffset}) is implemented 
+in modern texture shading hardware, such as the NV25 architecture.
+The image of the undistorted shape can be stored in a texture and accessed
+with texture coordinates offset by (read from) another texture.
+This is called an offset (dependent) texture access.
 
 The shape is given by Eq.~(\ref{eq:inside}), which under the 
 assumptions can be written as a point $(x,y)$ being inside the tearout,