3D graphics eBook - Course Materials Repository

Bilinear filtering 15
Limitations
Bilinear filtering is rather accurate until the scaling of the texture gets below half or above double the original size of
the texture - that is, if the texture was 256 pixels in each direction, scaling it to below 128 or above 512 pixels can
make the texture look bad, because of missing pixels or too much smoothness. Often, mipmapping is used to provide
a scaled-down version of the texture for better performance; however, the transition between two differently-sized
mipmaps on a texture in perspective using bilinear filtering can be very abrupt. Trilinear filtering, though somewhat
more complex, can make this transition smooth throughout.
For a quick demonstration of how a texel can be missing from a filtered texture, here's a list of numbers representing
the centers of boxes from an 8-texel-wide texture (in red and black), intermingled with the numbers from the centers
of boxes from a 3-texel-wide down-sampled texture (in blue). The red numbers represent texels that would not be
used in calculating the 3-texel texture at all.
0.0625, 0.1667, 0.1875, 0.3125, 0.4375, 0.5000, 0.5625, 0.6875, 0.8125, 0.8333, 0.9375
Special cases
Textures aren't infinite, in general, and sometimes one ends up with a pixel coordinate that lies outside the grid of
texel coordinates. There are a few ways to handle this:
• Wrap the texture, so that the last texel in a row also comes right before the first, and the last texel in a column also
comes right above the first. This works best when the texture is being tiled.
• Make the area outside the texture all one color. This may be of use for a texture designed to be laid over a solid
background or to be transparent.
• Repeat the edge texels out to infinity. This works best if the texture is not designed to be repeated.
Binary space partitioning
In computer science, binary space partitioning (BSP) is a method for recursively subdividing a space into convex
sets by hyperplanes. This subdivision gives rise to a representation of the scene by means of a tree data structure
known as a BSP tree.
Originally, this approach was proposed in 3D computer graphics to increase the rendering efficiency by
precomputing the BSP tree prior to low-level rendering operations. Some other applications include performing
geometrical operations with shapes (constructive solid geometry) in CAD, collision detection in robotics and 3D
computer games, and other computer applications that involve handling of complex spatial scenes.
Overview
In computer graphics it is desirable that the drawing of a scene be done both correctly and quickly. A simple way to
draw a scene is the painter's algorithm: draw it from back to front painting over the background with each closer
object. However, that approach is quite limited, since time is wasted drawing objects that will be overdrawn later,
and not all objects will be drawn correctly.
Z-buffering can ensure that scenes are drawn correctly and eliminate the ordering step of the painter's algorithm, but
it is expensive in terms of memory use. BSP trees will split up objects so that the painter's algorithm will draw them
correctly without need of a Z-buffer and eliminate the need to sort the objects; as a simple tree traversal will yield
them in the correct order. It also serves as a basis for other algorithms, such as visibility lists, which attempt to
reduce overdraw.
The downside is the requirement for a time consuming pre-processing of the scene, which makes it difficult and
inefficient to directly implement moving objects into a BSP tree. This is often overcome by using the BSP tree