True Impostors - Eric Risser

Abstract
True Impostors offers an efficient method for adding a large number
of simple models to any scene without having to render a large number
of polygons. The technique utilizes modern shading hardware
to perform ray casting into texture defined volumes. To achieve
this, a virtual screen is set up in texture space for each impostor
and inherits the same camera dependent orientation as the impostor.
Each pixel on the impostor corresponds to a point on its virtual
screen. By casting the viewing ray from this point into our texture
defined volumes, the correct color for the target pixel can be found.
The technique supports self-shadowing on models, reflection, refraction,
a simple animation scheme, and an efficient method for
finding distances through volumes.
Keywords: per-pixel displacement mapping, image based rendering,
impostor rendering, volumetric rendering, refraction
1 Introduction
Most interesting environments, natural as well as synthetic, tend to
be densely populated with many highly detailed objects. Rendering
such an environment would require a huge set of polygons as well
as a sophisticated scene graph and the overhead to run it. As an
alternative, image-based techniques have been explored to offer a
∗ e-mail: erisser@cs.ucf.edu
True Impostors
Eric Risser ∗
University of Central Florida
practical remedy to the problem. Amongst currently used imagebased
techniques, Impostors are a powerful technique that has been
widely used for many years in the graphics community. An impostor
is a two dimensional image rendered onto a billboard which
represents highly detailed geometry. Impostors can be generated
in real time or pre-computed and stored in memory, in both cases
the impostor is only accurate for a specific viewing direction, as the
view deviates from this ideal condition, the impostor loses accuracy.
The same impostor is reused until its visual error surpasses a
given arbitrary threshold in which case it is replaced with a more
accurate impostor.
True Impostors takes advantage of the latest graphics hardware to
achieve accurate geometric representation updated every frame for
any arbitrary viewing angle. It builds off Relief Mapping of Non-
Height Field Surfaces [Policarpo et al. 2006] and Parallax Occlusion
Mapping [Tatarchuk. 2006], extending past the goals of traditional
per-pixel displacement mapping techniques, which are to
add visually accurate sub-surface features to any arbitrary surface
by generating whole 3D objects on a billboard. True Impostors
distinguishes itself from previous per-pixel displacement mapping
impostor methods in two major areas.
1. By contributing a technique for rendering the impostor from
any viewing direction with no viewing limitations or restrictions.
2. Offering a GPU friendly ray tracing scheme designed to work
with per-pixel displacement mapping techniques, opening up
a wealth of potential ray tracing effects such as internal refraction.

2 Background
Parallax mapping [Kaneko et al. 2001] is a method for approximating
the parallax seen on uneven surfaces. Using the view ray transformed
to tangent space, parallax mapping samples a height texture
to find the approximate texture coordinate offset that will give the
illusion that a three dimensional structure is being rendered. Parallax
mapping is a crude approximation of displacement mapping. It
cannot simulate occlusion, self shadowing or silhouettes. Since it
requires only one additional texture read, it is a fast and therefore
relevant approximation for use in video games.
View dependent displacement mapping [Wang et al. 2003a] takes
a bi-directional texture function (BTF) approach to per-pixel displacement
mapping. This approach much like Impostors involves
pre-computing for each potential view direction an additional texture
map of the same dimensions as the source texture. The goal
of this method is to store the distance from the surface of our polygon
to the imaginary surface that is being viewed. The method
stores a five-dimensional map indexed by three position coordinates
and two angular coordinates. The pre-computed data is then compressed
and decompressed at runtime on the GPU. This method
produces good visual results but requires significant preprocessing
and storage to operate.
Relief mapping [Policarpo et al. 2005] can be considered an extension
of parallax mapping. Rather than a coarse approximation to
the solution, relief mapping performs a linear search or ”ray march”
along the view ray until it finds a collision with the surface at which
point a binary search is used to home in on the exact point of intersection.
Shell texture functions [Chen et al 2004] much like relief mapping
attempts to render the subsurface details of a polygon. However,
unlike relief mapping, which restricts itself to finding a new,
more detailed surface, shell texture functions attempts to ray trace a
complex volumetric data set. Shell texture functions produce highquality
visual results by accounting for sub-surface scattering. This
technique is notable due to the hybridization it attempts between
rasterization and ray tracing. It is however not viable for many applications
in the graphics community due to long pre-processing
times and a non-interactive frame rate.
Relief mapping of non-linear height-fields [Policarpo et al. 2006]
extends the concepts laid out in relief mapping by adding multiple
height-field data into the problem, creating distinct volumes.
The authors present an efficient method for determining whether
the view ray passes through one of these volumes.
Practical Dynamic Parallax occlusion mapping [Tatarchuk. 2006]
offers an alternative per-pixel displacement mapping solution. Similar
to relief mapping, a linear search is performed. Then a single
iteration of the secant method is used to fit a series of discrete
linear functions to the curve. This achieves a high rendering
speed by eliminating the need for branch dependent texture
lookups. Whereas the single iteration of the secant method does not
achieve the same level of accuracy as a true root finding method, in
practice there is very little rendering error making this technique
suitable for real-time applications.
2.1 Per-Pixel Displacement Mapping Review
All of the methods presented as background as well as True Impostors
can be classified under per-pixel displacement mapping. It is
crucial that the reader have a solid grasp of this type of problem.
By its definition the goal of per-pixel displacement mapping is to
displace or move a pixel from one point on the screen to another in
much the same way traditional vertex based displacement mapping
displaces the position of a vertex. A simple enough concept which
becomes difficult to implement due to the nature of rasterization and
the design of modern GPUs which has no mechanism for writing a
target pixels color value to a different pixel on the screen. Thus
a wealth of techniques have been proposed to solve this problem.
Generally when defining the color for a pixel two factors must be
taken into account, the color of the material of the surface at that
pixel and the amount of light being reflected towards the viewer.
Texture maps are the data structure that tends to store all of this
information, either as color or normal values. Therefore, a practical
version of our earlier problem becomes how can we for our current
pixel, find new texture coordinates that correspond to the point the
target pixel is actually representing.
To solve this problem the view vector needs to be known from the
camera to each pixel, transformed to texture space using the polygons
normal and tangent as well as the true topology of the object
that is being drawn. The topology can take on many forms stored
in many ways, for simplicity, though a single height-field texture is
used to define the true shape of the surface in figure 1.
Figure 1: View ray penetrating Geometry and corresponding
height-field.
Because the view ray projects itself as a line across the surface of
our polygon, it effectively takes a 1D slice out of the 2D function,
clarifying our problem to its true form, finding the first intersection
of a ray with an arbitrary function. Once this intersection has been
found, the corresponding texture coordinates can be used to find the
desired color for the pixel.
3 Method
A single texture can hold four height-fields, which can represent
many volumes. More texture data can be added to extend this to any
shape. Traditionally these height-fields would represent the surface
of a polygon, and the viewing vector would be transformed into the
polygon’s local coordinate frame with respect to its normal. However,
in this case the surface geometry and texture coordinates are
transformed with respect to the view direction, or in other words,
a billboard is generated which can then be used as a window to
view the height fields from any given direction. This is illustrated
in figure 2.

Figure 3: This Illustration walks through the True Impostors method step-by-step, note that at Cell E two separate directions can be taken
depending on the material type being rendered.
Figure 2: Visual representation of a quads texture coordinates transformed
into a 3D plane and rotated around the origin (left) and the
corresponding image it produces (right).
The right image shows a representation of the billboard’s texture
coordinates after they have been transformed into a 3D plane and
rotated around the functions in the center (represented by the fish).
The left image shows the perspective of the functions which would
be displayed on the billboard.
To expand on this concept please refer to figure 3. In cell A of the
image, the component of this method which operates on geometry
in world space is seen. The camera is viewing a quad which is ro-
tated so that its normal is the vector produced between the camera
and the center of the quad. As shown, texture coordinates are assigned
to each vertex. Cell B reveals texture space, traditionally
a two dimensional space, a third dimension W is added and the
UV coordinates are shifted by -0.5. In cell C the W component of
our texture coordinates are set to 1. Keep in mind that the texture
map only has UV components, so it is bound to two dimensions
and therefore can only be translated along the UV plane, where any
value of W will reference the same point. The texture map although
bound to the UV plane can represent volume data by treating each
of the four variables comprising a pixel as points on the W axis. In
cell D the projection of the texture volume into three dimensional
space is shown. The texture coordinates of each vertex are also rotated
around the origin in the same way as the original quad was
rotated around its origin to produce the billboard. Now the view
ray is introduced into the concept. The view ray is produced by
casting a ray from the camera to each vertex, during rasterization
both the texture coordinates and view rays stored in each vertex are
interpolated across the fragmented surface of the quad. This is conceptually
similar to ray casting/tracing where a viewing screen of
origin points is generated, where each point has a corresponding
vector to define a ray. It should also be noted that each individual
ray projects as a straight line onto the texture map plane and therefore
takes a 2D slice out of the 3D volume to evaluate for collisions.
This is shown in detail in cell E.
Still referring to figure 3, at this point two separate options exist depending
on the desired material type. For opaque objects ray casting
is the fastest and most accurate option available, a streamlined

approach to this has been laid out in Relief Mapping of Non Height
Field Surfaces [Policarpo et al. 2006] using a ray march followed
by binary search as shown in cells F-H. This finds the first point
of intersection into the volume. Due to the nature of GPU design,
it is impractical from an efficiency standpoint to exit out of a loop
early, therefore the maximum number of ray marches and texture
reads must be performed no matter how early in the search the first
collision is found. Rather than ignoring this ”free” data, a method
is proposed to add rendering support for translucent material types
through a localized approximation to ray tracing. Rather than performing
a binary search along the viewing ray, the points along the
W axis are used to define a linear equation for each height field as
shown in cell I. In cell J these linear equations are then tested for
intersection with the view ray in a similar fashion as shown in Parallax
Occlusion Mapping [Tatarchuk. 2006]. The intersection which
falls between the upper and lower bounding points is kept as the
final intersection point. Since the material is translucent the normal
is checked for this point and the view ray is refracted according to
a dielectric value either held constant for the shader or stored in an
extra color channel in one of the texture maps. Once the new view
direction is discovered, the ray march continues and the process is
repeated for any additional surfaces that are penetrated as shown
in cells K-M. By summing the distances traveled through any volume,
the total distance traveled through the model can be known
and used to compute the translucency for that pixel.
True Impostors also offers a simple yet effective animation scheme
in which the animation frames are tiled on a single texture, offering
quick look-ups using the pixel shader.
Figure 4: Animated texture map with cooresponding models.
Rather than using the entire texture to store a single model, the image
is partitioned into discrete equally sized regions each storing a
frame of the desired animation as shown in figure 4. To accommodate
the new data representation, the UV coordinates stored in each
vertex span the length of a single region as opposed to the entire
texture map. Also, the UV coordinates of the texture map are no
longer shifted by -.5, but shifted so that the middle of the target region
lies on the origin of the coordinate frame. The animation can
be looped through by passing a global time variable into the shader
and using it to select the current target region. This makes True Impostors
a powerful technique for rendering large herds of animals,
schools of fish, and flocks of birds.
4 Results and Analysis
True Impostors can produce nearly correct reproductions of geometry
on a single billboard for any possible viewing direction. This is
shown in Figure 5 where multiple dogs are displayed from arbitrary
directions. True Impostors is the first per-pixel displacement mapping
based impostor technique to achieve complete viewing freedom
and thus is the first of such techniques to represent objects in
true 3D.
In addition to viewing independence, this paper tackled a new
volume intersection/traversal method ideal for rendering translucent/refractive
objects which can be applied to any multiple layered
per-pixel displacement mapping technique. Figure 6 shows a glass
sphere rendered using True Impostors with correct double refraction.
A trace-through of the view vector is also shown to confirm
that True Impostors is properly rendering the object.
Figure 6: refraction through a glass sphere using True Impostors
Given the lack of a true root finding method during refractive rendering,
True Impostors suffers from very little error; however, there
is a case where minor artifacts will occur. When entering or leaving
a volume such that one of the linear steps falls on a pixel in
the texture map which does not define the volume being encountered,
there is a chance that the line-segment intersection test can
return a point that also does not lie on a pixel defining the target
volume. The normal of the surface is needed to refract the view ray,
in general this method rarely finds the exact point of intersection,
but since the surface and therefore normal is generally continuous,
the small level of error is unnoticeable by the human eye. However,
at such rare points where a normal not lying on our surface is
returned, the resulting image will show blatant artifacts. To soften
these artifacts, the normal textures are mipmapped so each sampled
point is actually the average of several neighboring points. For
the most part this alleviates the rendering error; this does however
leave a crease where two surfaces meet to form a volume. Because
multiple points on the normal map are averaged, there is no smooth
transition between layers defining a volume as shown in figure 7.
This crease can be remedied through a simple art hack. When generating
the normal maps for each surface, blend the color values
concentrated around the edge of a volume, this should force the
normals to conform at the edge and produce a smooth curve.
In addition to refraction, True Impostors can also reflect points on
a surface achieving complex local interactions between mirrored

Figure 5: The same impostor is shown from multiple arbitrary viewing directions. True Impostors is the first technique which has successfully
been able to render view directions which significantly deviate from the profile, as shown in the third and last image.
Figure 7: A visible crease is shown along the intersection of two
surfaces. Due to averaging normal values.
surfaces. As a proof of concept a sphere is rendered using reflection
in figure 8.
Figure 8: Reflective impostor.
The method performs similarly to other per-pixel displacement
mapping techniques; however, there are concerns unique to True
Impostors. Performance is fill-rate dependent. Since billboards can
occlude neighbors it is crucial to perform depth sorting on the CPU
to avoid overdraw. Since True Impostors is fill-rate dependent, level
of detail is intrinsic, and this is a great asset.
With True Impostors it is possible to represent more geometry on
screen at once then could be achieved using standard polygonal
means, an example is shown on the first page where a model of
Jupiter is rendered using a quarter of a million asteroids to comprise
its ring. True Impostors was implemented in C++ using DirectX
9. All benchmarks were taken using a GeForce 6800Go and two
GeForce 7800’s run in SLI. Although the vertex processor is crucial
to True Impostors, the resulting operations do not put a heavy
workload on the vertex processing unit and do not result in noticeable
drops in performance. The performance of this technique is
primarily determined by the fragment processing unit, the number
of pixels on the screen, the number of search steps taken for
each pixel, and which rendering technique is used. When performing
ray casting the performance mirrored that of Relief Mapping
of Non-Height-Field Surface Details [Policarpo et al. 2006] due to
the similar ray casting technique used in both methods. The Jupiter
model consisting of a quarter of a million impostors with a linear
search size of 10 steps and a binary search size of 8 steps rendered
in a 1024x768 window at 10 frames per second on the 6800Go and
35 - 40 frames per second on the 7800SLI. The ray tracing technique
was rendered in a 800x600 window using 20 search steps and
achieved on average 7-8 frames per second on the 6800Go and 25-
30 frames per second on the 7800SLI. No comparisons are made
between the performances of the two techniques due to the fundamentally
different rendering solutions they both offer. The only
generalized performance statement made about the two techniques
is that they both have been shown to achieve real time frame-rates
on modern graphics hardware.
5 Discussion
True Impostors offer a quick, efficient method for rendering large
numbers of animated opaque, reflective or refractive objects on the
GPU. It generates impostors with very little rendering error and offers
inherent per-pixel level of detail. These results are achieved
by building upon the concepts laid out in Relief Mapping of Non-
Height-Field Surface Details [Policarpo et al. 2006] and Parallax
Occlusion Mapping [Tatarchuk. 2006]. By representing volume
data as multiple height fields stored in traditional texture maps,
the vector processing nature of modern GPUs is exploited and a
high frame rate is achieved along with a low memory requirement.
By abandoning the restrictions inherent in keeping per-pixel displacement
mapping a subsurface detail technique, a new method for
rendering staggering amounts of faux-geometry has been achieved,
not by blurring the line between rasterization and ray tracing, but
through a hybrid approach, taking advantage of the best each has
to offer. This method is ideal for video games as it improves an
already widely used technique.

References
BLINN, J. F. 1978. Simulation of wrinkled surfaces. In SIGGRAPH
’78: Proceedings of the 5th annual conference on Computer
graphics and interactive techniques, ACM Press, New York, NY,
USA, 286–292.
CHEN, Y., TONG, X., WANG, J., LIN, S., GUO, B., AND SHUM,
H. 2004. Shell texture functions. In Transaction of Grpahics -
Proceedings of SIGGRAPH 2004 23. 343-352.
COOK, R. L. 1984. Shade trees. In SIGGRAPH ’84: Proceedings
of the 11th annual conference on Computer graphics and interactive
techniques, ACM Press, New York, NY, USA, 223–231.
HART, J. C. 1996. Sphere tracing: A geometric method for the
antialiased ray tracing of implicit surfaces. The Visual Computer
12, 10, 527–545.
HIRCHE, J., EHLERT, A., GUTHE, S., AND DOGGETT, M. 2004.
Hardware accelerated per-pixel displacement mapping. In GI
’04: Proceedings of the 2004 conference on Graphics interface,
Canadian Human-Computer Communications Society, School of
Computer Science, University of Waterloo, Waterloo, Ontario,
Canada, 153–158.
KANEKO, T., TAKAHEI, T., INAMI, M., KAWAKAMI, N.,
YANAGIDA, Y., AND MAEDA, T. 2001. Detailed shape representation
with parallax mapping. In Proceedings of the ICAT
2001, 205–208.
KAUTZ, J., AND SEIDEL, H.-P. 2001. Hardware accelerated displacement
mapping for image based rendering. In GRIN’01: No
description on Graphics interface 2001, Canadian Information
Processing Society, Toronto, Ont., Canada, Canada, 61–70.
KOLB, A., AND REZK-SALAMA, C. 2005. Efficient empty space
skipping for per-pixel displacement mapping. In Proc. Vision,
Modeling and Visualization.
MACIEL, P.W.C., SHIRLEY, P. 1995. Visual navigation fo large
environments using textured clusters. In Proceedings of the 1995
symposium on Interactive 3D graphics. 95-102.
MAX, N. 1998. Horizon mapping: shadows for bump-mapped
surfaces. In The Visual Computer 4, 2, 109–117.
MCGUIRE, M. 2005. Steep parallax mapping. In I3D 2005 Poster.
OLIVEIRA, M. M., BISHOP, G., AND MCALLISTER, D. 2000.
Relief texture mapping. In SIGGRAPH ’00: Proceedings of the
27th annual conference on Computer graphics and interactive
techniques, ACM Press/Addison-Wesley Publishing Co., New
York, NY, USA, 359–368.
PATTERSON, J. W., HOGGAR, S. G., AND LOGIE, J. R. 1991.
Inverse displacement mapping. Comput. Graph. Forum 10, 2,
129–139.
POLICARPO, F., OLIVEIRA, M. M., AND COMBA, J. L. D. 2005.
Real-time relief mapping on arbitrary polygonal surfaces. In
SI3D ’05: Proceedings of the 2005 symposium on Interactive
3D graphics and games, ACM Press, New York, NY, USA, 155–
162.
POLICARPO, F., OLIVEIRA, M. M. 2006. Relief Mapping of Non-
Height-Field Surface Details. In SI3D ’06:ACM SIGGRAPH
2006 Symposium on Interactive 3D Graphics and Games, Redwood
City, CA, USA, 55–62.
PRESS, W., FLANNERY, B., TEUKOLSKY, S., AND VETTERLING,
W. 2002. Root finding and non-linear sets of equations. In
Numerical Recipes in C, 354–360.
SCHAUFLER, G., AND PRIGLINGER, M. 1999. Horizon mapping:
shadows for bump-mapped surfaces. In Efficient displacement
mapping by image warping, 175–186.
SLOAN, P., AND COHEN, M., 2000. Interactive horizon mapping.
TATARCHUK. 2006. Dynamic parallax occlusion mapping with
approximate soft shadows. In SI3D ’06: Proceedings of the
2006 symposium on Interactive 3D graphics and games, Redwood
City, California, 63–69.
WALSH. 2003. Parallax mapping with offset limiting. In Infiniscape
Tech Report.
WANG, L., WANG, X., TONG, X., LIN, S., HU, S., GUO, B.,
AND SHUM, H.-Y. 2003. View-dependent displacement mapping.
ACM Trans. Graph. 22, 3, 334–339.
WANG, X., TONG, X., LIN, S., HU, S., GUO, B., AND SHUM,
H.-Y. 2003. Generalized displacement maps. In Eurographics
Symposium on Rendering, 227–233.
/////////////////////////////////////////////////////////////////////
// True Impostors //
/////////////////////////////////////////////////////////////////////
// this portion of code requires a quad with its true center at //
// the origin and the desired center stored as the normal //
/////////////////////////////////////////////////////////////////////
//calculate billboards normal
float3 quadNormal = normalize(in.normal.xyz - g_vEyePt.xyz);
//compute rotation matrices based on new quad normal
float2 eyeZ = normalize(float2(sqrt(pow(quadNormal.x,2) + pow(quadNormal.z, 2)),
quadNormal.y));
float2 eyeY = (normalize(float2(-quadNormal.z, quadNormal.x)));
xRot._m00 = 1; xRot._m01 = 0; xRot._m02 = 0; xRot._m03 = 0;
xRot._m10 = 0; xRot._m11 = eyeZ.x; xRot._m12 = eyeZ.y; xRot._m13 = 0;
xRot._m20 = 0; xRot._m21 = -eyeZ.y; xRot._m22 = eyeZ.x; xRot._m23 = 0;
xRot._m30 = 0; xRot._m31 = 0; xRot._m32 = 0; xRot._m33 = 1;
yRot._m00 = eyeY.x; yRot._m01 = 0; yRot._m02 = eyeY.y; yRot._m03 = 0;
yRot._m10 = 0; yRot._m11 = 1; yRot._m12 = 0; yRot._m13 = 0;
yRot._m20 = -eyeY.y; yRot._m21 = 0; yRot._m22 = eyeY.x; yRot._m23 = 0;
yRot._m30 = 0; yRot._m31 = 0; yRot._m32 = 0; yRot._m33 = 1;
World = mul(xRot, yRot);
//update vertex positions
in.pos = mul(in.pos, World);
in.pos.xyz += in.normal.xyz;
//generate texture plane
out.viewOrigin = float3(in.tex_coords.x + 0.5f, in.tex_coords.y - 0.5f, -1.0f);
out.viewOrigin = mul(out.viewOrigin, World);
out.viewOrigin = float3(out.viewOrigin.x + 0.5f, out.viewOrigin.y + 0.5f,
-out.viewOrigin.z);
//output the final position and view vector for each vertex
out.pos = mul(in.pos, g_mWorldViewProj);
out.viewVec = float4(normalize((in.pos.xyz)-(g_vEyePt.xyz)), 1);
True Impostors Vertex Shader Pseudo-code.

// True Impostors //
/////////////////////////////////////////////////////////////////////
// this portion of code steps through the linear and binary //
// searches of the ray-casting algorithm //
/////////////////////////////////////////////////////////////////////
int linear_search_steps = 10;
float depth_step=1.0/linear_search_steps;
float dis = depth_step;
float depth = 0;
float4 prePixelColor = float4(0, 0, 0, 0);//for finding collision layer
////////////////////////////////////////////////////////////
// linear search
////////////////////////////////////////////////////////////
for(int i=1; i 0) //no collision
{
prePixelColor = pixelColor;
dis+=depth_step;
}
////////////////////////////////////////////////////////////////
// bisection search
////////////////////////////////////////////////////////////////
for(int i = 1; (i < 8); i++)
{
}
tex_coords = (dis)*float2(-viewVec.x, -viewVec.y);
tex_coords += float2(viewOrigin.x, viewOrigin.y);
pixelColor = tex2D(heightSampler, tex_coords)*hscale+(1 - hscale)/2.0f-0.5;
depth = input.viewOrigin.z + dis*viewVec.z;
pixelColor.rgba = depth - pixelColor.rgba;
depth_step*=0.5f;
if((pixelColor.r*pixelColor.g*pixelColor.b*pixelColor.a) > 0) //no collision
{
dis+=depth_step;
}
else
{
dis-=depth_step;
}
Ray-Casting Pseudo-code.
/////////////////////////////////////////////////////////////////////
// True Impostors //
/////////////////////////////////////////////////////////////////////
// this portion of code contains the main loop which marches //
// through the volume, refracting the view vector at collisions //
/////////////////////////////////////////////////////////////////////
for(int i=1; i