"tower.inc" v1.1 - August 27, 1997
Author:  Norm Krumpe
e-mail:  krumpenj@muohio.edu

--------------------------------
What's new/improved since v1.0?
--------------------------------
The purpose of this release is to simplify the designating the size
of the Tower_Unit.  Rather than using Tower_Box1 and Tower_Box2 to
specify a "snug" box around your object, you simply need to define
Tower_Center, which is the center of the base of the Tower_Unit, and
Tower_UnitHeight, which is the height of the Tower_Unit.

While driving one day and looking at some water towers and radio
broadcasting antennas, it struck me that it would be nice to be
able to create a "tower" in POV-Ray by specifying what one "unit"
of the tower looks like, and describing how those units are stacked
on one another.

Thus, "tower.inc" was born.  There are a number of options that allow
all sorts of interesting figures, even if one starts with something as
simple as a box for an initial unit.  I've no doubt that others can
make more interesting towers than I.  If you've got a good one that you
wouldn't mind sending me for a re-zipped tutorial, I'd love to see it.
My e-mail address is krumpenj@muohio.edu

As this is my first attempt at an include file, I must ask that you be
as harsh as necessary so that I can guide any possible future efforts
in worthwhile directions.


-----------------
How to use it:
-----------------
It's really pretty easy.

1)  #declare the necessary variables
2)  #include "tower.inc"
3)  Play around with the variables to see what happens.

Anything left undeclared (or declared in a way that seems "ugly") is
repaired before rendering.

Note that the tower is always constructed centered about the origin,
and extends up the positive y-axis.

-----------------------------------------
Here is a description of the variables:
-----------------------------------------

Tower_Unit can basically be any POV-Ray object (as far as I can tell).

Tower_Center is an <x, y, z> vector that defines the location of the bottom
center of your Tower_Unit.  This vector will help tower.inc to correctly
position the units (and, consequently, the entire tower) over the origin.
  
Tower_UnitHeight is a scalar that allows you to specify the height of your
initial Tower_Unit.

(The defaults if Tower_Unit or Tower_Center or Tower_UnitHeight are not
declared are a box whose diagonally opposite corners are at <-1, 0, -1> and
<1, 1, 1>, and whose center is at <0,0,0>, with a height of 1.)

Tower_BottomScale is an <x, y, z> vector that scales the very bottom unit.
Tower_TopScale is an <x, y, z> vector that scales the very top unit.
Once these are declared, each successive unit from the bottom will
"approach" the scale factors of the top unit.  This can result in some
very interesting effects.  For example, you may want the x-value to shrink
from bottom to top, while the z-value expands.  (The defaults are <1,1,1>.) 
You have some control over just how the scale factors change using the...

Tower_ScaleType states how the Tower_BottomScale factor is "transformed"
into the Tower_TopScale:
If Tower_ScaleType is 0, the progression is arithmetic.  So, if you have 10
units, and the bottom x-scale factor is 1, and the top is 2, then the 10
x-scale factors from bottom to top will be 1, 1.1, 1.2, ..., 1.9, 2.
If Tower_ScaleType is 1, the progression is geometric.  So, if you have 10
units, and the bottom x-scale factor is 1, and the top is 2, then the 10
x-scale factors from bottom to top will be 1, 1.08, 1.17, 1.26, 1.36, 1.47,
1.59, 1.71, 1.85, 2.  In this case, each successive scale factor is
multiplied by 2^(1/9).  (The default is type 0.)

Tower_Space allows you to put space between each unit if you want.  
NOTE:  Though I've only played with it a little, it seems that some
interesting effects might be achieved by using negative numbers for
Tower_Space.  (The default is no space.) 
Again, you have some control over what "kind" of space you want using...

Tower_SpaceType allows you to control how the amount of space is determined
between units.
If Tower_SpaceType is 0, then the amount of space declared in Tower_Space
will be considered constant.  The same amount of space will be seen between
any 2 units.
If Tower_SpaceType is 1, then the amount of space declared in Tower_Space
will be considered as a "percent" of the HEIGHT OF THE PREVIOUS UNIT.  So,
if your scale factors are causing the heights of your units to shrink, then
the space BETWEEN the units would shrink in a corresponding manner.  (The
default is type 0.)

Tower_DivRotate specifies the number of degrees each successive unit will
be rotated.  The rotation will take place about the origin.
(The default is no rotation.)  

You may find that your tower grows much larger than you expected.  By
specifying Tower_Height, your final tower will be scaled down (or up) to
that desired height.  (The default is no scaling.)