home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The World of Computer Software
/
World_Of_Computer_Software-02-387-Vol-3of3.iso
/
r
/
rtag20.zip
/
RTAG.DOC
< prev
next >
Wrap
Text File
|
1993-03-04
|
86KB
|
1,807 lines
R T A G
Ray Tracing Animation Generator
A "shareware" program
Phillip H. Sherrod
Member, Association of Shareware Professionals (ASP)
RTAG is a program to facilitate the generation of ray
traced animations. RTAG is not a ray tracing program;
rather, it enables you to generate the appropriate
position of objects to produce an animation using the
ray tracing program of your choice. RTAG compiles a
programming language designed for animation generation.
This programming language contains full arithmetic
expressions, conditional control, looping, I/O, and a
rich set of library functions including spline path
generation. The output of RTAG is a set of files that
can be used to drive ray tracing programs such as
POV-Ray, or other ray tracers, to produce an image for
each frame.
RTAG -- Ray Tracing Animation Generator Page 1
INTRODUCTION TO ANIMATION GENERATION
An animation is composed of a sequence of individual images,
called "frames," which are displayed rapidly to give the illusion
of motion. Anyone who sets out to create an animation must deal
with two design issues: (1) the generation of the basic scene
(objects, colors, lights, etc.), and (2) the changing position of
the objects between frames. RTAG deals with the second of these
issues -- object motion. The first issue, basic scene design and
rendering, is carred out by the ray tracing program of your
choice (POV-Ray, Polyray, BOB, etc.).
RTAG reads an animation control file that you create and
generates one or more files that automate the rendering of
individual frames and the construction of the animation sequence.
The animation control file is the focus of this manual.
RTAG implements an animation language with a syntax similar to C.
Although simple in comparison to full featured languages such as
C and Pascal, the RTAG language is far from trivial. It provides
full arithmetic and logical expressions, control statements (IF),
loop statement (FOR, WHILE, and DO), a rich set of library
functions (trig, log, roots, spline, etc.), and statements for
writing commands to the output files which will be used to
generate the frames. Using the RTAG language you can perform
realistic simulations of physical processes such as
accelerations, falling objects, and interactions between objects.
RTAG also can be used as a general purpose programming language.
RAY TRACING DRIVER FILES
The basic purpose of RTAG is to produce a set of files which will
cause ray tracing programs such as POV-Ray, Polyray, Vivid, BOB,
and other ray tracers to generate the sequence of frames for an
animation.
All ray tracers accept some sort of scene description file in
which you specify the position of objects, colors, textures,
camera angle, etc. With rare exeception, one run of a ray tracer
with one scene description produces one image file. In order to
produce an animation you must run the ray tracer once for each
frame and vary the position of the objects and/or camera between
frames to produce the illusion of motion. This means that the
scene description file must be different for each frame.
Fortunately, all good ray tracers provide a facility for
including one or more external files while processing the scene
description. In the case of POV-Ray this is accomplished with
the "#include" statement. Other tracers have similar statements.
Using this facility you can have a common scene description file
and place only the commands to describe the positions of moving
RTAG -- Ray Tracing Animation Generator Page 2
objects in a separate file that is included in the scene. For
example, consider this simple POV-Ray scene description file:
#include "colors.inc"
#include "shapes.inc"
#include "move.inc"
camera {
location <.5 1 -22> direction <0 0 1.5>
up <0 1 0> right <1.33 0 0> look_at <0 4 0>
}
object { light_source { <6 15 -4> color White} }
object {
sphere { <xpos ypos 0> .5}
texture { color red .9 green 0 blue .1 ambient .8 }
}
This scene has a camera, a single light source, and a ball. The
position of the ball is specified as "<xpos ypos 0>" but note
that xpos and ypos are not defined in the file. Rather, the
values of xpos and ypos are defined in a separate file named
"move.inc" that in included in this scene. Typical statements in
move.inc are as follows:
#declare xpos = 3
#declare ypos = 4
To simulate motion of the ball you would prepare a separate
move.inc file for each frame with slightly altered values for
xpos and ypos. Since there will be an include file for each
frame, they are typically given names containing the frame
numbers such as "MOVE001.INC", "MOVE002.INC", etc. A primary
purpose of RTAG is to automate the generation of these include
files.
In addition to a scene description file and a separate include
file for each frame, you also need a DOS batch file to cause the
ray tracing program to be run for each frame. RTAG also helps
you produce this file.
For each frame, the batch file will contain commands to perform
the following operations: (1) make the appropriate include file
the current include file for the next image generation;
(2) execute the ray tracing program which will generate an image
based on frame-dependent data in the current include file;
(3) additional commands to delete intermediate files or pack
together the frame files. Typical commands written to the batch
file for a frame are:
COPY MOVE001.INC MOVE.INC
POVRAY +iMOVE.POV +oMOVE.TGA
RTAG -- Ray Tracing Animation Generator Page 3
Rather than having RTAG produce a separate include file for each
frame (which can end up being a lot of files), it is also
possible to write commands to the batch file to cause the include
file to be created just before it is needed by the ray tracing
program. To do this, use the DOS ECHO command with the ">"
redirection operator to create the file and the ">>" operator to
add additional commands to the file. The following is an example
of commands that create an include file named MOVE.INC, write two
commands into it, and then call POV-Ray to render the image:
ECHO #declare xpos = 2.5 > move.inc
ECHO #declare ypos = 8.6 >> move.inc
POVRAY +iMOVE.POV +oMOVE.TGA
Note that the ">" redirection operator creates a new file so it
should be used with the first ECHO command for each frame. The
">>" redirection operator appends to the end of a file so it
should be used for additional ECHO commands for the frame.
To summarize, there are two methods for producing the include
file for a frame: (1) have RTAG generate a separate file with a
unique name that is copied (or renamed) to the name used by the
#include statement; or (2) use ECHO commands in the batch file to
generate the include file just before invoking the ray tracing
program for the frame.
FILES PRODUCED BY RTAG
Include files -- If you wish to have RTAG generate a separate
include file for each frame, you must use an OFILE command
to declare the file name. The name must include one or more
'#' characters which are replaced by the frame number to
generate the actual include file name. The NEXTFRAME
statement increments the frame number and opens the next
include file being created. OWRITE commands are used to
write information to the currently open include file.
If you create the include file by writing ECHO commands to
the batch file, then you will NOT use the OFILE and OWRITE
statements which cause RTAG to generate a separate include
file for each frame.
Batch file -- This is a DOS batch (.BAT) file containing the
commands to perform the following operations for each frame:
(1) make the appropriate include file the current include
file for the next image generation (or generate the include
file); (2) execute the ray tracing program which will
generate an image based on frame-dependent data in the
current include file; (3) additional commands to delete
intermediate files or pack together the frame files. Use
BWRITE statements in your control file to write to the batch
file. The BFILE statement declares the name of the batch
RTAG -- Ray Tracing Animation Generator Page 4
file. This file is not created unless you use the BFILE and
BWRITE commands.
Auxiliary files -- RTAG includes statements for opening,
creating, reading from, and writing to auxiliary files.
Auxiliary input files can be used to transfer animation data
from other programs to RTAG. One use of an auxiliary output
file is to store the names of the generated targa or GIF
files so that a subsequent program such as DTA can read this
file to determine which files to string together in the
final animation file.
Listing file -- This file has the same name as the animation
control file but an extension of ".LST". It contains the
same output displayed by RTAG on the screen during an
animation generation run. You can use PRINT statements
within your control file to write output to the screen and
the listing file.
AUXILIARY PROGRAMS
RTAG is one component in the set of programs needed to produce
and display an animation. In addition to RTAG you will need the
following programs:
Ray Tracing Program -- There are several excellent ray tracing
programs available as freeware or shareware. Three programs
with which I am familiar are POV-Ray (freeware) by Drew
Wells and the POV team (CompuServe 73767,1244); Polyray
(shareware) by Alexander R. Enzmann (CompuServe 70323,2461);
and BOB by Christopher Watkins, Stephen Coy, and Mark Finlay
(included with the excellent book "Photorealism and Ray
Tracing in C").
GIF generator -- Most ray tracing programs output "targa" files
which contain higher resolution images than usually can be
displayed. These targa files must be converted into GIF or
other image formats before they can be displayed. One fine
freeware program for doing this is Piclab by Lee Daniel
Crocker and the Stone Soup Group (CompuServe 73407,2030).
Scene viewer -- When designing a scene you will need a program to
display the TGA or GIF file for an individual frame of the
animation. There are many programs available to do this. A
popular shareware choice is CSHOW by Bob Berry (CompuServe
76555,167).
Animation sequencer -- Once the individual frame images have been
generated, they must be combined into a single file that can
be displayed rapidly. A shareware program which I use for
this is DTA by David K. Mason (CompuServe 76546,1321). DTA
reads the targa or GIF files produced by the ray tracer and
RTAG -- Ray Tracing Animation Generator Page 5
produces a .FLI (flick) file that can be displayed as an
animation.
Animation display -- This program reads the finished animation
file and displays it on your screen. A popular shareware
program for displaying .FLI files is PLAY.EXE by Trilobyte
(CompuServe 72330,3276).
These programs, and many others related to ray tracing and
animation, are available in the libraries of the CompuServe
GRAPHDEV forum. This is also an excellent place for posting
messages or getting help regarding ray tracing and animation.
Two bulletin boards which specialize in graphics development are
"You Can Call Me Ray," 708-358-5611; and "The Graphics
Alternative," 510-524-2780.
RUNNING RTAG
Once you create an RTAG control file, you can use RTAG to compile
and execute it by issuing a DOS command of the form:
RTAG control_file [option1] [option2]...
where "control_file" is the name of the control file. If no file
extension is specified, ".RTA" is used by default.
Following the control file name you may specify the options
described below. If more than one option is provided, they must
be separated by spaces. The option letters are not case
sensitive. Values specified with command line options override
the corresponding values specified in the control file.
/B=file -- Specifies the name of the batch file. The batch file
name can also be specified using a BFILE statement in your
control file. The default extension is ".BAT".
/F=number -- Specifies the first frame that is to produce output.
Output generated with the BWRITE and OWRITE functions is
discarded for frames prior to this number. The default
value is 1.
/L=number -- Specifies the last frame that is to produce output.
Output generated with the BWRITE and OWRITE functions is
discarded for frames following this number. By default,
there is no last frame (i.e., all frames are output).
/N -- Specifies that no output is to be written to the batch and
include files. This is useful when you are debugging an
animation control file and want to test it without
generating the output files. Output generated by PRINTF and
WRITE functions always is written, even if this option is
RTAG -- Ray Tracing Animation Generator Page 6
specified.
/O=file -- Specifies the name of the include files generated
during the run. Include file names must include the string
'###' (1 to 5 '#' characters) which is replaced by the frame
number. The output file names can also be specified by an
OFILE statement in your control file. The default extension
is ".INC".
/P -- Causes the entire control file to be listed on the screen
and written to the listing file. Normally only error
messages and output generated by PRINTF statements are
displayed.
/S=number -- Specifies the number of steps between frames whose
output is to be generated. Output is discarded for frames
between the step frames if a value other than 1 is
specified. The default value is 1. If stepping is enabled,
the first frame is generated and then frames are skipped up
to first+step. The sequence continues with subsequent
frames. This option is useful for producing an abbreviated
set of frames for evaluation and debugging purposes.
/T -- Specifies that each source statement is to be displayed
before it is executed. This is useful for debugging
purposes.
THE RTAG ANIMATION CONTROL FILE
RTAG reads an animation control file that you create, compiles
the commands, and executes the resulting program. The commands
in the control file are formed from the RTAG animation language
which is described in the sections that follow. However, before
getting into a detailed discussion of the animation language,
let's look at a simple example to get a feeling for the language.
This example is a complete RTAG command file which will generate
the appropriate commands to move an object on a spline path that
passes through a specified set of x,y,z coordinates:
// Simple animation example.
// Declare variables
var lastframe = 60; // Generate 60 frames
var x,y,z;
// Declare files
bfile "move"; // Batch file MOVE.BAT
// Begin main animation loop to generate 60 frames.
while (curframe < lastframe) {
// Begin the next frame (this increments curframe)
nextframe;
// Use spline function to compute x,y,z position.
x = spline(curframe, 1,-8, 20,0, 40,5, 60,8);
y = spline(curframe, 1,1, 20,5, 40,5, 60,1);
RTAG -- Ray Tracing Animation Generator Page 7
z = spline(curframe, 1,0, 20,4, 40,6, 60,10);
// Report the position
printf("At frame `curframe`, x=`x`, y=`y`, z=`z`\n");
// Write commands to the batch file.
// These commands create a move.inc include file.
bwrite("ECHO #declare xpos = `x` > move.inc\n");
bwrite("ECHO #declare ypos = `y` >> move.inc\n");
bwrite("ECHO #declare zpos = `z` >> move.inc\n");
// Generate command to render the image.
bwrite("call render move move`###`\n");
}
// Write final batch command that runs DTA to build the animation.
epilog;
bwrite("call dta move\n");
ARITHMETIC AND LOGICAL EXPRESSIONS
Much of the power of RTAG comes from its ability to perform
mathematical calculations. This is important for any type of
animation generation, but is especially critical for physical
system simulations. This section explains the arithmetic
operators and built in functions that may be used in arithmetic
expressions.
The following arithmetic operators may be used in expressions:
++ add 1 to a variable
-- subtract 1 from a variable
+ addition
- subtraction or unary minus
* multiplication
/ division
% modulo
** or ^ exponentiation
The "++" and "--" operators may be used either immediately before
or after a variable name. If they are used before the name, the
increment or decrement is performed before the value of the
variable is used in the expression. If they are used after the
name, the value of the variable before being modified is used in
the expression and then the increment or decrement takes place.
For example, the sequence:
a = 3;
b = 3;
x = ++a;
y = b++;
assigns the value 4 to x and 3 to y. At the end of the sequence,
both a and b have the value 4.
RTAG -- Ray Tracing Animation Generator Page 8
The following assignment operators can be used in expressions:
variable = expression; // Assign expression to variable
variable += expression; // Add expression to variable
variable -= expression; // Subtract expression from variable
variable *= expression; // Multiply variable by expression
variable /= expression; // Divide variable by expression
The following operators compare two values and produce a value of
1 if the comparison is true, or 0 if the comparison is false:
== Equal
!= Not equal
<= Less than or equal
>= Greater than or equal
< Less than
> Greater than
The following logical operators may be used:
! Logical NOT (negates true and false)
&& AND
|| OR
There are two other special operators: "[]" (square brackets)
which enclose subscripts on arrays, and "," (comma) which is used
to specify left-to-right, sequential evaluation of a list of
expressions.
Operator precedence, in decreasing order, is as follows:
subscript, unary minus, logical NOT, ++ and --, exponentation,
multiplication, division and modulo, addition and subtraction,
relational (comparison), logical (AND and OR), assignment, comma.
Parentheses may be used to group terms.
Numeric Constants
Numeric constants may be written in their natural form (1, 0,
1.5, .0003, etc.) or in exponential form, n.nnnEppp, where n.nnn
is the base value and ppp is the power of ten by which the base
is multiplied. For example, the number 1.5E4 is equivalent to
15000. All numbers are treated as "floating point" values,
regardless of whether a decimal point is specified or not. As a
convenience for entering time values, if a value contains one or
more colons, the portion to the left of the colon is multiplied
by 60. For example, 1:00 is equivalent to 60; 1:00:00 is
equivalent to 3600.
RTAG -- Ray Tracing Animation Generator Page 9
Built-in Constant
The symbolic name "PI" is equivalent to the value of pi,
3.14159... You may write PI using either upper or lower case.
Built in Functions
The following functions are built into RTAG and may be used in
expressions:
ABS(x) -- Absolute value of x.
ACOS(x) -- Arc cosine of x. Angles are measured in degrees.
ASIN(x) -- Arc sine of x. Angles are measured in degrees.
ATAN(x) -- Arc tangent of x. Angles are measured in degrees.
CEIL(x) -- Ceiling of x (an equivalent name for this function is
INT). Returns the smallest integer that is at least as
large as x. For example, CEIL(1.5)=2; CEIL(4)=4;
CEIL(-2.6)=-2.
CLOSE(file) -- Close the specified file.
COS(x) -- Cosine of x. Angles are measured in degrees.
COSH(x) -- Hyperbolic cosine of x.
COT(x) -- Cotangent of x. (COT(x) = 1/TAN(x)). Angle in degrees.
CREATE("file name") -- Create a new auxiliary data file. The
value returned by this function is a file number that can be
used with subsequent WRITE functions. See the description
of auxiliary file I/O for additional information.
CSC(X) -- Cosecant of x. (CSC(x) = 1/SIN(x)). Angle in degrees.
DEG(x) -- Converts an angle, x, measured in radians to the
equivalent number of degrees.
EXP(x) -- e (base of natural logarithms) raised to the x power.
FAC(x) -- x factorial (x!). The FAC function is computed using
the GAMMA function (FAC(x)=GAMMA(x+1)) so non-integer
argument values may be computed.
FLOOR(x) -- Floor of x. Returns the largest integer that is less
than or equal to x. For example, FLOOR(2.5)=2; FLOOR(4)=4;
FLOOR(-3.6)=-4.
RTAG -- Ray Tracing Animation Generator Page 10
GAMMA(x) -- Gamma function. Note, GAMMA(x+1) = x! (x factorial).
INT(x) -- Ceiling of x (an equivalent name for this function is
CEIL). Returns the smallest integer that is at least as
large as x. For example, INT(1.5)=2; INT(4)=4;
INT(-2.6)=-2.
LINEAR(t, t1,x1, t2,x2, ... tn,xn) -- Perform linear
interpolation between a set of points. If the value of a
function is x1 at some point t1, x2 at t2, etc., this
function determines the value at some arbitrary point, t,
where t falls in the range (t1,tn). The first argument to
the LINEAR function is the value t at which the
interpolation is to be performed. The remaining arguments
are (ti,xi) data pairs. For example, consider the function
LINEAR(t, 0,0, 1,6, 2,4). This specifies that when t is 0,
the value of the function is 0, when t is 1, the value is 6,
and when t is 2 the value is 4. If this function is called
with a t value of 0.5, the returned value of the function
will be 3. If the function is called with a t value of 1.5,
the returned value will be 5. You can use expressions as
arguments to this function. For example, the following
function invocation is valid: LINEAR(t, starttime,basex,
starttime+3,midx, endtime,midx*2). If the function is
called with a t value that is outside the range (t1,tn)
(i.e., beyond either end point), then the nearest end point
and the second closest point are used to extrapolate to the
specified t value. See also the description of the SPLINE
function.
LOG(x) -- Natural logarithm of x.
LOG10(x) -- Base 10 logarithm of x.
MAX(x1,x2) -- Maximum value of x1 or x2.
MIN(x1,x2) -- Minimum value of x1 or x2.
MOD(x1,x2) -- x1 modulo x2. The MOD function calculates the
floating-point remainder, f, of x1/(i*x2) such that
x1=i*x2+f, where i is an integer; f has the same sign as x1,
and the absolute value of f is less than the absolute value
of x2. The % operator perform the same operation.
MOREDATA(file) -- This function checks to see if there is another
data record available in the external file whose file number
is specified as the argument. If there is a record
available, this function returns the value true (1), if not,
it returns false (0). This function does not consume any
data in the file, you must use the READ statement to
actually read the next record. You can call MOREDATA any
number of times without disturbing the next record in the
file. See the section on auxiliary file I/O for additional
RTAG -- Ray Tracing Animation Generator Page 11
information.
NPD(x,mean,std) -- Normal probability distribution of x with
specified mean and standard deviation. X is in units of
standard deviations from the mean.
OPEN("file name") -- Open an existing file for reading. The
value returned by this function is a file number that can be
used with subsequent READ functions. See the description of
auxiliary file I/O for additional information.
PAREA(x) -- Area under the normal probability distribution curve
from -infinity to x. (i.e., integral from -infinity to x of
NORMAL(x)).
PRINTF("format"[,expression1,expression2,...]) -- Evaluate the
expressions (if any) and write the values with the specified
formatting string to the console and the listing file.
PULSE(a,x,b) -- Pulse function. If the value of x is less than a
or greater than b, the value of the function is 0. If x is
greater than or equal to a and less than or equal to b, the
value of the function is 1. In other words, it is 1 for the
domain (a,b) and zero elsewhere. If you need a function
that is zero in the domain (a,b) and 1 elsewhere, use the
expression (1-PULSE(a,x,b)).
RAD(x) -- Converts an angle measured in degrees to the equivalent
number of radians.
RANDOM() -- Returns a random value uniformly distributed in the
range 0 to 1. You can use the srand system variable to
specify a starting seed.
READ(file,variable1,variable2,...) -- Read one line from the
specified file, scan the input line for values, and assign
the values to the specified variables.
ROUND(x) -- Rounds x to the nearest integer. For example,
ROUND(1.1)=1; ROUND(1.8)=2; ROUND(-2.8)=-3;
SEC(x) -- Secant of x. (SEC(x) = 1/COS(x)). Angle in degrees.
SEL(a1,a2,v1,v2) -- If a1 is less than a2 then the value of the
function is v1. If a1 is greater than or equal to a2, then
the value of the function is v2.
SIN(x) -- Sine of x. Angles are measured in degrees.
SINH(x) -- Hyperbolic sine of x.
RTAG -- Ray Tracing Animation Generator Page 12
SPLINE(t, t1,x1, t2,x2, ... tn,xn) -- Perform a cubic spline
interpolation between a set of points. A spline is a smooth
path (continuous first and second derivatives) that passes
through a set of points. The SPLINE function is very useful
in animations because it allows you to easily construct a
smooth path for the motion of some object (or the camera).
If the value of a function is x1 at some point t1, x2 at t2,
etc., this function determines the value at some arbitrary
point, t, where t falls in the range (t1,tn). The first
argument to the SPLINE function is the value t at which the
interpolation is to be performed. The remaining arguments
are (ti,xi) data pairs. You can use expressions as
arguments to this function. For example, the following
function invocation is valid: SPLINE(t, starttime,basex,
starttime+3,midx, endtime,midx*2). If the function is
called with a t value that is outside the range (t1,tn)
(i.e., beyond either end point), then the value of the
function at the nearest end point and the slope of the
function at that point are used to extrapolate in a linear
fashion to the specified t value. See also the description
of the LINEAR function.
SQRT(x) -- Square root of x.
STEP(a,x) -- Step function. If x is less than a, the value of
the function is 0. If x is greater than or equal to a, the
value of the function is 1. If you need a function which is
1 up to a certain value and then 0 beyond that value, use
the expression STEP(x,a).
TAN(x) -- Tangent of x. Angles are measured in degrees.
TANH(x) -- Hyperbolic tangent of x.
WRITE(file,"format"[,expression1,expression2,...]) -- Evaluate
the expressions (if any) and write the values with the
specified formatting string to auxiliary output file whose
file number is specified as the first argument.
NOTES ON THE SPLINE AND LINEAR FUNCTIONS
RTAG includes two library functions for performing interpolation:
LINEAR and SPLINE. If you have two pairs of values, (t1,x1) and
(t2,x2), these functions determine the value of x that
corresponds to some value of t between t1 and t2. If you have
more than two pairs, the function determines the value of x that
is on the segment that spans the specified value of t.
The function parameters, t and x, can represent any type of
value. However, in animations t is usually a time value or frame
number, and x is a position (either in the X, Y, or Z dimension).
RTAG -- Ray Tracing Animation Generator Page 13
If you want an object to follow a path through a set of three
dimensional points, you have to use three statements, each with
an interpolation function. For example, if at frame 1 you want
an object to be at (-8,0,-3), frame 20 to be at (0,5,-1), frame
40 to be at (2,2,0), and frame 60 to be at (7,4,2), then you
could use the following statements:
while (curframe <= 60) {
nextframe;
x = spline(curframe, 1,-8, 20,0, 40,2, 60,7);
y = spline(curframe, 1,0, 20,5, 40,2, 60,4);
z = spline(curframe, 1,-3, 20,-1, 40,0, 60,2);
<< other statements >>
}
The spline function will force the object to be at the specified
x,y,z coordinate at frames 1, 20, 40, and 60, and will generate
intermediate positions between these frames.
While the method explained above of specifying absolute frame
numbers works well, you will have to change the values in the
function specification if you change the total number of frames
in the animation. A better approach is to use the percentage of
the total animation as the control values and use the expression
(100*(curframe-1)/(lastframe-1)) to specify the position along
the path. Note that the a value must be specified for lastframe.
The following program illustrates this approach:
var x,y,z,position;
var lastframe = 50; // Animation will have 50 frames
while (curframe < lastframe) {
nextframe; // This increments curframe
position = 100*(curframe-1)/(lastframe-1);
x = spline(position, 0,-8, 40,0, 60,2, 100,7);
y = spline(curframe, 0,0, 40,5, 60,2, 100,4);
z = spline(curframe, 0,-3, 40,-1, 60,0, 100,2);
<< statements to output position >>
}
If the path described by a spline function completes a closed
circuit, a smoother transition can be accomplished by specifying
an extra point beyond either end which matches the next point on
the path. The following statements illustrate this for forming a
roughly circular path (a better way to do this would be to use
sin and cos functions):
position = 100*(curframe-1)/(lastframe-1);
x = spline(position, -20,0.3, 0,1.0, 20,0.3, 40,-0.8,
60,-0.8, 80,0.3, 100,1.0, 120,0.3);
y = spline(position, -20,-1.0, 0,0.0, 20,1.0, 40,0.6,
60,-0.6, 80,-1.0, 100,0.0, 120,1.0);
RTAG -- Ray Tracing Animation Generator Page 14
Note that the first point specified (-20) and the last point
(120) will never be reached since the value of position ranges
from 0 to 100. However, because the spline function depends not
only on the current position but also on the points on either
side, specifying these points smooths out the transition near the
end points. This trick does not apply to spline curves that are
not closed on themselves.
THE ANIMATION CONTROL LANGUAGE
The RTAG animation control language is similar to other modern
programming languages such as C. It provides the tools you need
to easily perform animation simulations and generate the
necessary output files to drive the ray tracing and auxiliary
programs.
COMMENTS
The beginning of a comment is denoted with "//" (two consecutive
slash characters). Everything from the "//" sequence to the end
of the line is treated as a comment. Comments may be on lines by
themselves or on the ends of other statements. You can also
specify a comment by beginning the comment with the "/*"
character sequence. All characters following this are treated as
comments up to the matching "*/" sequence. The following lines
illustrate both types of comments:
// Begin main simulation loop
y = y + timestep * yvelocity; // Advance y position
/*
* This is a comment.
*/
z = y / 5; /* This is a comment too */
BASIC STATEMENT SYNTAX
The RTAG language has a syntax that is very similar to C:
statements are terminated with a semicolon, and brace characters
("{" and "}") are used to group statements.
DECLARATION OF VARIABLES (The VAR Statatement)
All variables used in your animation control file must be
declared before they are used. This is done using the VAR
statement which may optionally assign an initial value to the
variable. If no initial value is specified, 0 is used by
default. VAR is a declarative statement: that is, it declares
the existance of the variable and assigns an initial value, it
RTAG -- Ray Tracing Animation Generator Page 15
does not reassign the value to the variable if the VAR statement
appears in a loop.
Variable names may be up to 30 characters long. They ARE case
sensitive. Keywords (FOR, WHILE, VAR, etc.) and library function
names (SIN, COS, ABS, etc.) are NOT case sensitive. All
variables are double precision (64 bit) floating point values.
The syntax of the VAR statement is:
VAR variable1[=value], variable2[=value], ...;
You may use as many VAR statements as you need. The following
are examples of this statement:
var x, y, speed = 5;
var Acceleration = 2.5;
In addition to simple scalar variables, RTAG also allows you to
use one-dimensional array variables. To declare an array
variable, follow the name of the variable with the number of
elements enclosed in square brackets. For example, the following
command declares a variable named speeds that will have 20
values:
var speeds[20];
If you wish to assign initial values to an array, enclose the
list of values in braces. For example,
var xpos[3] = {1.2, 2.7, 4.6};
Subscripts follow the C convention of being 0 based. That is,
the first element of an array is referenced using a subscript
value of 0. For example, if the variable x is declared with
three elements (var x[3]) then the elements would be referenced
as x[0], x[1], and x[2]. The expression x[3] would NOT be valid.
In addition to your own variables, RTAG provides several system
variables. If you do not provide VAR statements for these
variables, they are defined automatically at the start of a run
and RTAG assigns their values.
Variable Default Meaning
---------- ------- -------------------------------------------
curframe 0 The current frame number. Set by NEXTFRAME.
firstframe 1 The first frame that will generate output.
lastframe 999999 The last frame that will generate output.
stepinc 1 The step increment between frames.
srand 1 Seed for random number generator.
These variables may be used in your animation control file just
like ordinary variables. If you want to set different default
RTAG -- Ray Tracing Animation Generator Page 16
values for firstframe, lastframe, stepinc or srand, use a VAR
statement and specify an initial value. For example, the
following commands would cause frames 20 through 40 to be output:
var firstframe = 20;
var lastframe = 40;
The default values, or the values specified by VAR statements,
can be overridden by qualifiers on the command line. /F sets
firstframe, /L sets lastframe, and /S sets stepinc.
The srand system variable is used to set a starting "seed" value
for the RANDOM() function. The default value for srand is 1.
For a given starting seed value, the pseudorandom sequence is
always the same.
OUTPUT FILE DECLARATIONS
RTAG is capable of producing multiple files during each run.
Most of these files are optional and will only be produced if you
include the appropriate statements in your control file.
The listing file is always produced. It has the same name as the
animation control file but with an extension of ".LST".
Most RTAG runs will produce a batch file to drive the ray tracing
program. The batch file may contain commands to generate the
appropriate include file for each frame or you may choose to have
RTAG generate the full set of include files separate from the
batch file. If you wish to generate a batch file you must place
a command of the following form in your control file:
BFILE "name";
where 'name' is the name of the batch file. The default
extension is ".BAT". Note that the file name must be enclosed on
quote marks.
The batch file normally contains a set of commands to render each
frame. Typically, the commands for each frame perform the
following actions:
1. Generate an include file with object position information.
2. Run the ray tracer using the current include file.
The BWRITE function is used to write to the batch file. The
batch file is optional and is generated only if you use a BFILE
statement.
RTAG -- Ray Tracing Animation Generator Page 17
If you wish to have RTAG generate a set of include files, you
must use the following command to declare the names of the files:
OFILE "name";
If the OFILE statement is used, one output file is generated for
each frame. The output file name must include a string of one to
seven '#' characters. These characters are replaced by the
current frame number when the file is opened. For example,
consider the following command:
ofile "bounc###.inc";
Then for frame 27 the name of the created file will be
BOUNC027.INC. The default extension is ".INC". The NEXTFRAME
command closes the current output file, increments the frame
number, and opens the next output file (assuming the OFILE
statement was specified). The last output file is closed when
the program stops. The OWRITE function writes lines to the
currently open output file.
RTAG can also create or read from auxiliary data files. This is
described in a subsequent section.
ASSIGNMENT STATEMENT
The assignment statement is an executable statement that
evaluates an expression and assigns its value to a variable. The
syntax for an assignment statement is:
variable = expression; // Assign expression to variable
variable += expression; // Add expression to variable
variable -= expression; // Subtract expression from variable
variable *= expression; // Multiply variable by expression
variable /= expression; // Divide variable by expression
where "variable" is a previously declared variable which may be
subscripted and "expression" is a valid arithmetic or logical
expression following the rules explained earlier. If the
expression involves a relational comparison operator (e.g., <, >,
>=, etc.) or a logical operation (&&, ||, !), the value 1 is used
for true and 0 for false.
RTAG -- Ray Tracing Animation Generator Page 18
IF STATEMENT
The form of the IF statement is:
IF (expression) statement1 [ELSE statement2]
If the expression is true (not zero) statement1 is executed, if
the expression is false (0) and the ELSE clause is specified,
statement2 is executed. The ELSE clause and the second set of
controlled statements are optional. You may control groups of
statements by enclosing them in braces. The following are
examples of valid IF statements:
if (x > bigx) bigx = x;
if (x <= 10) {
y = linear(x, 0,0, 10,6);
z = .5 * x;
} else {
y = y + yspeed * timestep;
z = .3 * x;
}
WHILE STATEMENT
The WHILE statement loops until the controlling expression
becomes false (0) or a BREAK statement is executed within the
loop. The form of the WHILE statement is:
WHILE (expression) {
<< controlled statements >>
}
Each time around the loop the expression is evaluated. If it is
true (non zero) the controlled statements are executed and then
the process repeats until the expression becomes false. If a
BREAK statement is executed within the loop, execution of the
loop terminates and control is transferred to the first statement
beyond the end of the loop. If a CONTINUE statement is executed
in the loop, control is transferred to the conditional test at
the top of the loop. The following is an example of a WHILE
statement:
while (x < 5) {
x = x + xmove;
y = y + ymove;
}
RTAG -- Ray Tracing Animation Generator Page 19
DO STATEMENT
The DO statement is very similar to the WHILE statement except
the control expression is evaluated at the end of the loop rather
than the beginning. This causes the loop always to be executed
at least once. The form of the DO statement is:
DO {
<< controlled statements >>
WHILE (expression);
For each iteration of the loop the controlled statements are
executed and then the conditional expression is evaluated. If it
is true (non-zero) control transfers to the first controlled
statement at the top of the loop. A BREAK statement may be used
to terminate the loop before the conditional expression is
evaluated. A CONTINUE statement can be used to cause control to
be transferred from within the loop to the point where the
conditional expression is evaluated. The following is an example
of a DO statement:
do {
read(infile,lastflag,x[numpoints++]);
} while (!lastflag);
FOR STATEMENT
The FOR statement is a looping control statement similar to the
WHILE statement; however, the FOR statement also allows you to
specify initialization expressions that are executed once at the
beginning of the loop, and loop-end expressions that are executed
at the end of each loop cycle. The form of the FOR statement is:
FOR (expression1; expression2; expression3) statement
Execution of a FOR statement proceeds as follows:
1. Evaluate expression1. Typically this expression will include
assignment operators ("=") to set initial values for loop
variables. If you need more than one initial expression, specify
them as a list separated by commas.
2. Evaluate expression2. If its value is false (0) terminate
the FOR statement and transfer control to the statement that
follows the controlled statement. If expression2 is true,
proceed to the next step.
3. Execute the controlled statement. If more than one statement
is to be controlled, enclose them with brace characters ("{"
"}").
RTAG -- Ray Tracing Animation Generator Page 20
4. Evaluate expression3. This expression will typically contain
operators such as "++", "+=", "--", or "-=" to modify the value
of a loop variable.
5. Transfer control to step 2, where expression2 is once again
evaluated.
The following is an example of a FOR statement:
for (time=starttime; time<endtime; time+=timestep) {
<< controlled statements >>
}
BREAK STATEMENT
The BREAK statement can be used in FOR, WHILE, and DO loops to
terminate the loop and cause control to transfer to the statement
beyond the end of the loop. The following is an example of a
BREAK statement:
time = 0;
x = 0;
while (time < endtime) {
x += delta * xspeed;
if (x > 10) break;
}
CONTINUE STATEMENT
The CONTINUE statement can be used in FOR, WHILE, and DO loops to
terminate the current iteration and begin the next one. When
CONTINUE is executed in a WHILE or DO statement, control is
transferred to the point in the loop where the loop control
expression is evaluated. When CONTINUE is executed in a FOR
statement, control is transferred to the bottom of the loop where
expression3 is evaluated (which normally augments the values of
the loop variables for the next iteration).
STOP STATEMENT
The STOP statement terminates the execution of RTAG and closes
all output files. An implicit STOP occurs if you "fall through"
the bottom of your animation control file. The following is an
example of the STOP statement:
while (curframe < 60) {
<< controlled statements >>
if (xposition1 >= xposition2) stop;
}
RTAG -- Ray Tracing Animation Generator Page 21
WRITE STATEMENTS
RTAG has three functions for writing output to standard files.
These functions and the files they write to are as follows:
PRINTF -- Listing file (also displayed on screen).
OWRITE -- Output file (OFILE).
BWRITE -- Batch file (BFILE).
Since the form for these functions is the same (except for the
keyword), the PRINTF statement will be used in the illustrations.
The form of the function is:
printf("string"[,expression1, expression2,...])
where "string" is a quoted text string that may including
variable and expression replacement operators. You can cause the
current value of a variable to be substituted into a string by
inserting the variable name in the string enclosed by "`"
characters. Note, this is not the apostrophe, it is the accent
character that is on the same key as the tilde on most keyboards.
You can use the SUBCHAR statement (see below) to change the
character used to mark a variable value substitution. For
example, the following statement prints the values of the xpos
and ypos variables:
printf("X position is `xpos`, and Y position is `ypos`\n");
When this statement is executed `xpos` and `ypos` are replaced by
the current values of the xpos and ypos variables.
Following the C model, control characters are placed in the
string by prededing the character with a backslash. The
following table indicates each of the valid control sequences:
\a -- Bell character (0x07).
\b -- Backspace (0x08).
\f -- Form feed (0x0C);
\n -- End of print line (carriage-return, line-feed).
\r -- Carriage return only.
\" -- Quote character.
\\ -- Literal backslash character (i.e., replace "\\" with "\").
\xddd -- Hexadecimal value 0xddd.
If the sequence `###` (1 to 7 '#' characters enclosed by "`"
characters) appears in the string, the pound signs are replaced
by the current frame number with leading zeros. If the sequence
`+++` (1 to 7 '+' characters) appears in the string, the plus
signs are replaced by a value equal to the current frame number
plus 1. In addition, the strings `ofile` and `bfile` are
replaced by the names of the output file, and batch file
respectively. The string `file` is replaced by the name of the
input animation command file with any device, directory, and
RTAG -- Ray Tracing Animation Generator Page 22
extension removed.
You can also substitute the values of expressions. To do this,
use the C programming notation "%w.dlf" where 'w' is the overall
field width and 'd' is the number of decimal places. For
example, the following statement prints the value of an
expression:
printf("The diagonal distance is %5.1lf\n", sqrt(xd^2 + yd^2));
SUBCHAR STATEMENT
The SUBCHAR statement specifies which character is to be used in
write strings to enclose the names of variables whose values are
to be substituted in the string. The default character is "`" --
the accent character which is usually on the same key as the
tilde character. The form of the statement is:
SUBCHAR "char";
where "char" is a single character that must be included in quote
marks. For example, the following statement declares dollar sign
to be the substitution marker character:
subchar "$";
NEXTFRAME STATEMENT
The NEXTFRAME statement performs the following actions: (1) close
the currently open output file, if any; (2) increment the current
frame number (and curframe variable); (3) if an OFILE statement
was used, open a new output file with the current frame number
substituted for the "###" characters in the file name.
You must execute a NEXTFRAME statement before you can use an
OWRITE function. PRINT, BWRITE and WRITE functions can be
executed before the first NEXTFRAME command. The last output
file is closed when your program stops.
EPILOG STATEMENT
The EPILOG statement (which may also be spelled EPILOGUE) informs
RTAG that the last frame has been completed and that subsequent
BWRITE function calls are unconditionally to generate output
regardless of the setting of the firstframe, lastframe, and
stepinc values. Otherwise BWRITE functions do not generate
output if they occur after the last frame, or between frames if
stepinc is not 1. Commonly statements using the BWRITE function
are used after EPILOG to write some "end-of-all-frames"
termination statements to the batch file, such as commands to run
RTAG -- Ray Tracing Animation Generator Page 23
DTA to build the animation sequence.
SELF-CONTINUING BATCH FILES
Because so much computer time is required to create ray traced
animations, it is sometimes necessary to produce the frames using
a series of runs rather than in a single run. Using RTAG it is
easy to produce BAT files that automatically will restart with
the first frame that does not exist. This is done by generating
"IF EXIST...GOTO" commands as part of the batch file. For each
frame you cause the BAT file to check if the TGA file exists; if
so, control skips to the test for the next file. The following
is a skeleton of an RTAG program to generate these statements.
Note the use of the `###` sequence to substitute the current
frame number and the `+++` sequence to substitute the next frame
number.
while (curframe < lastframe) {
nextframe;
bwrite(":do`###`\n");
bwrite("if exist tour`###`.tga goto do`+++`\n");
<< other commands to write info for this frame >>
}
epilog;
bwrite(":do`+++`\n");
bwrite("call dodta TOUR /S8\n");
The commands written to the BAT file for each frame have the
following form:
:do001
if exist tour001.tga goto do002
<< commands to generate frame 1 >>
:do002
if exist tour002.tga goto do003
<< commands to generate frame 2 >>
:do003
AUXILIARY DATA FILES
RTAG provides functions to open, close, read from, and write to
auxiliary data files. This is useful if some other program has
computed object positions or other data that affects the
animation.
Up to 30 auxiliary data files can be open at once. The files are
identified by numbers (also called file "handles") that are
assigned by RTAG at the time that the file is opened. The file
numbers can be reused by closing and reopening files. You must
use the VAR statement to declare variables to hold the file
numbers.
RTAG -- Ray Tracing Animation Generator Page 24
Opening a File for Reading
The form of the statement used to open an existing file for
reading is:
variable = open("file name");
where 'variable' is a varible you have previously declared with a
VAR statement. When RTAG opens the file it generates a unique
file number and assignes it to the variable on the left of the
equal sign. This file number can be used subsequently in READ
functions. An example of this statement is
infile = open("spiral.dat");
Creating an Output File
The form of the statement used to create an auxiliary output file
is
variable = create("file name");
When RTAG creates the file it assignes a unique file number to
the specified variable. This file number can be used
subsequently in WRITE functions. An example of this statement is
outfile = create("trace.dat");
Closing an Auxiliary File
The function used to close an auxiliary file is:
close(file)
where 'file' is a variable that has a file number. For example:
close(outfile);
Any open files are closed automatically when your program
terminates.
Reading from an Auxiliary File
You may read data from an open auxiliary file by using a READ
function of the following form:
read(file,variable1,variable2,...);
RTAG -- Ray Tracing Animation Generator Page 25
Where 'file' is a file number assigned by a previously executed
OPEN function. Each READ function call reads the next line of
data from the file and assigns numeric values to the list of
variables you specify. There must be at least as many data
values on the line as the number of variables specified with the
READ function (additional values are ignored). The data values
may be separated by spaces, tabs, and/or commas. Numeric values
may be specified in the same form as numbers within an RTAG
animation control file (natural, exponential, or dd:dd:dd).
The MOREDATA function can be used to control how many records are
read from the file. The value of MOREDATA(file) is true (1) if
there is another, unread, record available in the file; its value
is false (0) if there is no more data available in the file.
MOREDATA does not consume any data, it just checks for the
availability of data. The following statements would read all
data in a file and generate a frame file for each record:
var f,xpos,ypos;
f = open("indata.dat");
while (moredata(f)) {
nextframe;
read(f,xpos,ypos);
owrite("#declare xpos=`xpos`\n");
owrite("#declare ypos=`ypos`\n");
}
Writing to an Auxiliary File
The form of the function used to write to an auxiliary file is:
WRITE(file,"string"[,expression1,expression2,...]);
where 'file' is a variable containing a file number assigned by a
previously executed CREATE function. "string" is a quoted string
of the same form as described for the PRINT, OWRITE and BWRITE
functions. The string may include variable and expression
replacement operators. Expression1, expression2, etc. are
optional expressions whose values are to be substituted into the
string where "%w.dlf" sequences occur. The following statements
illustrate the use of the WRITE function:
var f,x,y;
f = create("sine.out");
for (x=0; x<360; x+=2) {
y = sin(x);
write(f,"x=`x`, y=`y`\n");
}
close(f);
RTAG -- Ray Tracing Animation Generator Page 26
NOTES ABOUT THE SYSTEM VARIABLES
There are four system variables that affect frame generation:
curframe, firstframe, lastframe, and stepinc. Curframe has the
current frame number. Its initial value is 0 before the first
frame is started. The NEXTFRAME statement closes the output file
(OFILE) if it is open, increments the value of curframe by 1, and
opens a new output file (if an OFILE statement was specified).
The following loop would be appropriate to generate an animation
with 60 frames:
while (curframe < 60) {
nextframe;
<< commands to generate frame >>
}
By default, firstframe has a value of 1, lastframe has a value of
999999, and stepinc has a value of 1. There are two ways to
assign different values to these variables: the VAR statement or
with command line options (/F, /L, and /S). The main reason for
setting firstframe and stepinc to something other than 1 is to
make an abbreviated animation which will give you an idea of how
objects will move without spending the time rending all of the
images for a full animation. The following example shows a
command file that will generate images for frames 10 through 60,
stepping 5 between the frames:
var firstframe = 10;
var lastframe = 60;
var stepinc = 5;
while (curframe < lastframe) {
nextframe;
<< commands to generate frame >>
}
The effect of setting firstframe to something other than 1 may be
different than what you expect. The current frame number
(curframe) ALWAYS starts at 0 and increments by 1. If firstframe
is set to something other than 1, the OWRITE and BWRITE functions
have no effect until the frame number reaches the firstframe
value (i.e., when executed they do not write anything to a file).
The reason that firstframe works like this is that when
performing a simulation the state of the system usually depends
on previous iterations (e.g., the position of a falling ball
depends on how long it has been dropping and whether it has
already hit the floor). Because of this it is necessary to start
at the beginning each time. However, by cancelling the actions
of the OWRITE and BWRITE functions prior to firstframe, you can
save the expense of rendering frames before the one of interest.
There are two exceptions to this rule. BWRITE functions always
generate output before the first execution of the NEXTFRAME
statement regardless of the value of firstframe, lastframe, and
RTAG -- Ray Tracing Animation Generator Page 27
stepinc. This is done so that initialization statements can be
generated before the frame generation iteration begins. BWRITE
functions also always generate output after the execution of an
EPILOG statement. This is done so that you can write cleanup and
termination commands to the batch and auxiliary files. PRINTF
and WRITE functions generate output regardless of the value of
firstframe.
The effect of stepinc is similar to firstframe. The NEXTFRAME
statement ALWAYS increments the frame number by 1. If stepinc is
not 1, OWRITE and BWRITE functions are disabled between the
steps. BWRITE always generates output before the execution of
the first NEXTFRAME statement and after execution of an EPILOG
statement.
ANIMATION AND TIME CONTROL
Time is an essential component of any animation. Except for
special effects, time advances by a constant amount between
frames. Most RTAG animation control files will have an outer
loop advancing through either frames or time. For simple
animations it is usually easier to loop through frames,
calculating the simulated time as a function of the frame number.
For example, the following statements would move an object along
a sinusoidal (wavey) path using the frame number as an argument
to the SIN function:
while (curframe < 60) {
nextframe;
x = -6 + (curframe / 5);
y = 3 * sin(curframe * 12);
<< other statements to generate output >>
}
This approach works well for simple animations where the position
of the objects can be calculated as a direct function of the
frame number. However, for more complex animations, especially
those involving acceleration and interactions between objects, it
may be necessary to perform the simulation with smaller time
steps than the time between frames. In other words, the outer
loop should advance the simulation time and frames should be
generated at periodic intervals to take "snapshots" of the
objects. The following statements illustrate this approach:
RTAG -- Ray Tracing Animation Generator Page 28
for (time=0; time<endtime; time+=timestep) {
// Calculate updated positions of objects
x = x + xspeed * timestep;
y = y + yspeed * timestep;
<< other statements to compute object positions >>
// See if it is time to generate a frame
if (time >= frametime) {
// Generate a frame
nextframe;
<< statements to write to files >>
// Calculate when next frame should be generated
frametime = frametime + sampletime;
}
}
EXAMPLE ANIMATIONS
The RTAG distribution comes with several example files which are
explained below. For each example there is an ".RTA" animation
command file and a ".POV" POV-Ray scene description file.
TOUR -- There is a simulated "city" (would you believe a village
with high rise buildings?). The camera begins from the
distance, sweeps down and along "Main Street", circles a
dome structure at the end, and then climbs while still
keeping the buildings in view as it moves away. The SPLINE
function is used both to control the position of the camera
and also the location that the camera is looking at. This
120-frame animation takes about 6 hours to render in 320x200
size with anti-aliasing turned on running on a 486/33 using
POV-Ray.
BOUNC -- Bouncing ball simulation. A ball rolls down a ramp,
falls, bounces twice, and ends up in landing in a can. This
is a good example of a simulation where time is advanced in
small steps and frames are generated periodically as
"snapshots" of the scene. The position of the ball is
calculated using elementary physics: The speed of an
accelerating object at the end of a time interval is equal
to its speed at the beginning plus the acceleration
multiplied by the time interval. The position at the end of
an interval is equal to the position at the start of the
interval plus the speed multiplied by the time interval. An
animation with 60 to 70 frames seems to work best with this
example.
ORBIT -- Orbital simulation. Three planets move in elliptical
orbits around a sun. One of the planets has a moon in a
circular orbit. The orbital speeds of the planets follow
Kepler's laws. If you look closely you can see the shadow
as one planet eclipes another. The 200 frame sequence takes
about 4 hours to render on a 386/25 with coprocessor.
RTAG -- Ray Tracing Animation Generator Page 29
USE AND DISTRIBUTION OF RTAG
You are welcome to make copies of this program and pass them on
to friends or post this program on bulletin boards or distribute
it via disk catalog services provided the entire RTAG
distribution is included in its original, unmodified form. A
distribution fee may be charged for the cost of the diskette,
shipping and handling. However, RTAG may not be sold, or
incorporated in another product that is sold, without the
permission of Phillip H. Sherrod. Vendors are encouraged to
contact the author to get the most recent version of RTAG.
As a shareware product, you are granted a no-cost, trial period
of 30 days during which you may evaluate RTAG. If you find RTAG
to be useful, educational, and/or entertaining, and continue to
use it beyond the 30 day trial period, you are required to
compensate the author by sending the registration form printed at
the end of this document (and in REGISTER.DOC) with the
appropriate registration fee to help cover the development and
support of RTAG.
In return for registering, you will be authorized to continue
using RTAG beyond the trial period and you will receive the most
recent version of the program, a laser-printed, bound manual, and
three months of support via telephone, mail, or CompuServe. Your
registration fee will be refunded if you encounter a serious bug
that cannot be corrected.
You are welcome to contact the author:
Phillip H. Sherrod
4410 Gerald Place
Nashville, TN 37205-3806 USA
615-292-2881 (evenings)
CompuServe: 76166,2640
Internet: 76166.2640@compuserve.com
Both the RTAG program and documentation are copyright (c) 1993 by
Phillip H. Sherrod. You are not authorized to modify the
program. "RTAG" is a trademark.
This program is produced by a member of the Association of
Shareware Professionals (ASP). ASP wants to make sure that the
shareware principle works for you. If you are unable to resolve
a shareware-related problem with an ASP member by contacting the
member directly, ASP may be able to help. The ASP Ombudsman can
help you resolve a dispute or problem with an ASP member, but
does not provide technical support for members' products. Please
write to the ASP Ombudsman at 545 Grover Road, Muskegon, MI 49442
or send a CompuServe message via CompuServe Mail to ASP Ombudsman
7007,3536.
RTAG -- Ray Tracing Animation Generator Page 30
DISCLAIMER
RTAG is provided "as is" without warranty of any kind, either
expressed or implied. This program may contain "bugs" and
inaccuracies, and its results should not be assumed to be correct
unless they are verified by independent means. The author
assumes no responsibility for the use of RTAG and will not be
responsible for any damage resulting from its use.
RTAG -- Ray Tracing Animation Generator Page 31
MATHPLOT and NONLIN
If you like RTAG, you should check out the Mathplot and Nonlin
programs by the same author.
Mathplot allows you to specify complicated mathematical functions
using ordinary algebraic expressions and immediately plot them.
Four types of functions may be specified: cartesian (Y=f(X));
parametric cartesian (Y=f(T) and X=f(T)); polar
(Radius=f(Angle)); and parametric polar (Radius=f(T) and
Angle=f(T)). Up to four functions may be plotted simultaneously.
Scaling is automatic. Options are available to control axis
display and labeling as well as grid lines. Hard copy output may
be generated as well as screen display. Mathplot is an ideal
tool for engineers, scientists, math and science teachers, and
anyone else who needs to quickly visualize mathematical
functions. Mathplot requires a CGA, EGA, or VGA monitor.
Hardcopy plots can be displayed on HP LaserJet printers.
Nonlin performs linear and nonlinear statistical regression
analysis. Nonlin determines the values of parameters for an
equation, whose form you specify, that cause the equation to best
fit a set of data values. Nonlin can handle linear,
multivariate, polynomial, and general nonlinear equations. You
specify the form of the equation using normal algebraic notation.
The data values and fitted equation can be displayed on the
screen or an HP LaserJet printer. Nonlin is the best and most
powerful shareware regression program available.
RTAG -- Ray Tracing Animation Generator Page 32
TSX-32 Multi-User Operating System
If you have a need for a multi-user, multi-tasking operating
system, you should look into TSX-32. TSX-32 is a full-featured,
high performance, multi-user operating system for the 386 and 486
that provides both 32-bit and 16-bit program support. With
facilities such as multitasking and multisessions, networking,
virtual memory, X-Windows, background batch queues, data caching,
file access control, real-time, and dial-in support, TSX-32
provides a solid environment for a wide range of applications.
TSX-32 is not a limited, 16-bit, multi-DOS add-on. Rather, it is
a complete 32-bit operating system which makes full use of the
hardware's potential, including protected mode execution, virtual
memory, and demand paging. TSX-32 sites range from small systems
with 2-3 terminals to large installations with more than 64
terminals on a single 386.
In addition to supporting most popular 16-bit DOS programs,
TSX-32 also provides a 32-bit "flat" address space with both Phar
Lap and DPMI compatible modes of execution.
Since the DOS file structure is standard for TSX-32, you can
directly read and write DOS disks. And, you can run DOS part of
the time and TSX-32 the rest of the time on the same computer.
TSX-32 allows each user to control up to 10 sessions. Programs
can also "fork" subtasks for multi-threaded applications. The
patented Adaptive Scheduling Algorithm provides consistently good
response time under varying conditions.
The TSX-32 network option provides industry standard TCP/IP
networking through Ethernet and serial lines. Programs can
access files on remote machines as easily as on their own
machine. The SET HOST command allows a user on one machine to
log onto another computer in the network. FTP, Telnet, and NFS
are available for interoperability with other systems.
TSX-32 allows simultaneous real-time program execution with
normal time-sharing operations. Real-time programs can connect
to interrupts, access device control ports, and preempt other
operations when necessary. TSX-32 is an ideal process control or
data collection system.
TSX-32 is, quite simply, the best and most powerful operating
system available for the 386 and 486. For additional information
contact:
S&H Computer Systems, Inc.
1027 17th Avenue South
Nashville, TN 37212 USA
615-327-3670 (voice)
615-321-5929 (fax)
CompuServe: 71333,27
RTAG -- Ray Tracing Animation Generator Page 33
=====================================================================
Software Order Form
=====================================================================
Name ______________________________________________________
Address ___________________________________________________
City _______________________ State _______ Zip ___________
Telephone _________________________________________________
CompuServe account (optional) _____________________________
RTAG version ______________________________________________
Bulletin board where you found RTAG _______________________
Comments __________________________________________________
Check the boxes which indicate your order type:
___ I wish to register RTAG ($20).
___ I wish to order Mathplot ($20).
___ I wish to order Nonlin ($25)
Add $5 to the total amount of the order if the software is being
shipped out of the United States.
In return for registering, you will receive the most recent
version of the program, a laser-printed, bound copy of the
manual, and three months of telephone or CompuServe support.
Your registration fee will be refunded if you find a serious bug
that cannot be corrected.
Distribution disk choice (check one):
3.50" HD (1.4 MB) ______
5.25" HD (1.2 MB) ______
5.25" DD (360 KB) ______
Send this form with the amount indicated to the author:
Phillip H. Sherrod
4410 Gerald Place
Nashville, TN 37205-3806 USA
615-292-2881 (evenings)
CompuServe: 76166,2640
Internet: 76166.2640@compuserve.com
