Star Fields. Remember the golden olden days of demos? They all had a starfield and
some scrolly text. In the traditional resolution of 320x200, these stars could look really
terrible. The distant stars, moving very slowly, would wiggle their way from the centre of the
screen, hopping discreetly from one pixel to the next. The low resolution of the screen made
the slow movement of the pixels quite ugly. What is needed is some way to overcome this finite
resolution. The answer is Antialiasing.
Note:In this article I will distinguish between pixels on the screen, and the Wupixels we
are trying to render. I shall use the term 'Pixels' to refer to pixels on the screen. 'Particles'
will refer to the Wupixels we are trying to render using 'pixels'.
Here is a small program I wrote a long time ago in BASIC to demonstrate the wu pixels.
Apologies for the fact that it is quite slow. A new demo, written in C, will be available soon.
On the left we have the particles in the positions we would like to render them. On the right
are the antialiased versions.
Up this close, these antialiased particles don't look like anything special. However, when
you use them to plot a large number of slowly moving pixels, the effect is really quite pleasing.
PropertiesThe total brightness of the pixels plotted equals the brightness of the origional particle.
The Wupixels have the following properties:
The centre of brightness of the Wupixel is located at the non-integer position of the origional particle.
MethodThere are several ways to plot antialiased particles. You can plot square, unit size particles,
which are the easiest. You can plot round unit sized particles which are slightly harder and look
almost identical. You can also plot larger particles. In this case round versions look better.
In any case, the brightness of any pixel plotted will be equal to the area covered by
Unit SquaresThese are the easiest to plot. For each pixel covered by the particle, calculate the area
covered by the particle. Multiply this by the brightness of the particle, and plot that pixel.
A unit square particle can cover a maximum of 4 pixels.
Pseudocode to render a Wupixel at (wx, wy) with brightness wb
INTEGER: x, y ' Integer coordinates of Wupixel
FLOAT: fx, fy ' The fraction part of the coordinates
INTEGER: btl, btr, bbl, bbr ' Brightness of the 4 pixels covered by particle
' (top left, top right, bottom left, bottom right)
x = int(wx) ' Calculate the coordinates of the top left pixel
y = int(wy) '
fx = wx - x ' Calculate the
fy = wy - y '
btl = (1-fx) * (1-fy) * wb ' Calculate the brightness of each of the 4 pixels
btr = (fx) * (1-fy) * wb ' and multiply bu the brightness
bbl = (1-fx) * (fy) * wb '
bbr = (fx) * (fy) * wb '
plot pixel with brightness btl at (x, y) ' Plot those pixels
plot pixel with brightness btr at (x+1, y) '
plot pixel with brightness bbl at (x, y+1) '
plot pixel with brightness bbr at (x+1, y+1) '
That gives you the idea behind the method. I shall leave it up to you to optimise it. The
best method I have found is simply to create a lookup table containing 256 wupixels. This only
Other Shapes and SizesYou needn't limit yourself to unit squares. Almost any size and shape is possible, although
the it is only really possible to distinguish different shapes when they are relative large.
The best way to create arbitary shapes and sizes is to render them several times larger, then
resample them down.
For example, a three pixel wide, round particle. Render the particle much larger, and
resample it down. Do this for several offsets of X and Y between 0 and 1 and store them in a