Most aspects of the shader can be controled via parameters that can be
assigned values by "uniform" clauses in the scene file. For setails of
all the available control parameters see the comments in the  shader's
source file. However in what follows I provide a somewhat higher level
overview of the various groups of control parameters.

The full set of control parameters that may be specified in the  scene
file is
 
   uniform int   FunctionId;
   uniform int   FunctionMode;
   uniform int   MinIterate;
   uniform int   MaxIterate;
   uniform float FunctionDuration;
   uniform float IterationDuration;

   uniform int   TransitionMode;
   uniform float TransitionFraction;

   uniform vec2  PreAdd;
   uniform vec2  PreScale;
   uniform float PreRotate;
   uniform float PrePower;

   uniform vec2  PostAdd;
   uniform vec2  PostScale;
   uniform float PostRotate;
   uniform float PostPower;

   uniform int   DomainMapMode;
   uniform vec2  DomainMapScale;
   uniform float DomainMapRotation;
   uniform int   DomainMapScaleMode;

   uniform int   DomainTrimMode;
   uniform vec4  DomainTrimParams;
   uniform vec4  TrimColour;

   uniform int   ColourScheme;
   uniform float ColourPeriod;
   uniform float ColourScale;

   uniform int   ContourMode;
   uniform vec4  ContourPowerScale;
   uniform vec4  ContourDensity;
   uniform vec4  ContourDamping;
   uniform vec2  ContourSharpness;
   uniform vec2  ContourFadeRate;

   uniform vec4  NanColour;
   uniform float Translucency;

   uniform int   DataPanel;
   uniform vec4  DataPanelCycle;

 Note, the above list shows how they are declared in the shader, in the
 scene file the syntax is

   uniform: name, type, value,...

Thse parameters can be regarded as falling into a number  of  groups  of
related parameters, each of which are described below.

Function selection
==================

   uniform int   FunctionId;
   uniform int   FunctionMode;
   uniform int   MinIterate;
   uniform int   MaxIterate;
   uniform float FunctionDuration;
   uniform float IterationDuration;

These parameters control what function is to be selected for evalutation
and how that selection changes with time.  Normal usage  is to select an
initial function using FunctionId and how long it is to be displayed for
using FunctionDuration.  Once  the  specified  time has elapsed the next
function in sequence is used - unless the FunctionDuration is zero which
is treated as a special case and inhibits stepping through the functions
and only evaluates the function specified by FunctionId itself. Actualy,
for reasons of convenience of implementation, a function duration of 0.0
is replaced by a large value corresponding to many  days,  but  for  all
practical purposes that inhibits stepping through the functions.

This basic usage can be modified in two ways

  1) FunctionMode changes  the  argument  to  the  function
     replacing z by 1/z, log(z),  log(1/z)  etc.  For  full
     details refer to the comments in the shader source.

  2) The function evaluation may be iterated,  i.e. instead
     of evaluating f(z) the functions f(f(z)),  f(f(f(z))),
     etc. are evaluated.  The iteration limits and the time
     time for each iteration are controlled via MinIterate,
     MaxIterate and IterationDuration.  See the comments in
     the shader shader's source for details.

Transition control
==================

   uniform int   TransitionMode;
   uniform float TransitionFraction;

By default the transitions from displaying the results for one function,
or for one prticular iteration depth of a function to  displaying  those
for the next are instantaneous.  This  behaviour  can be changed so that
the transition is gradual which produces a more pleasing effect. This is
controlled by the TransitionMode and TransitionFraction parameters.  See
the comments in the source file for details.

Function argument and result modifiers
======================================

   uniform vec2  PreAdd;
   uniform vec2  PreScale;
   uniform float PreRotate;
   uniform float PrePower;

   uniform vec2  PostAdd;
   uniform vec2  PostScale;
   uniform float PostRotate;
   uniform float PostPower;

This set of parameters allow the argument of the function or its  result 
to be modified by adding a constant complex value  (x+i*y),  multiplying
its x and y components by constants or changing its phase , theta in the
z=R*exp(theta) representaton, by adding a constant angle. See the source
file for details. The pre-scaling is useful to effectvely zoom in or out
of the area covered by the screen and pre-rotation is useful  to  change
the orientation, typically by 90 degrees.  PrePower is of particular use
when combined with a circular DomainMapMode that is then trimmed as this
combination can be used to create images that are rounded rectangles.

Note, there is some overlap of functionality  between  these  parameters
and the following set, the domain selection control parameters.  This is
for historical reasons and reflects the order in which the various parts
of the shader were developed.

Domain selection
================

   uniform int   DomainMapMode;
   uniform vec2  DomainMapScale;
   uniform float DomainMapRotation;
   uniform int   DomainMapScaleMode;

   uniform int   DomainTrimMode;
   uniform vec4  DomainTrimParams;
   uniform vec4  TrimColour;

This set of parameters control how the domain of the function, i.e. what
part of the infinite complex plane is covered and how it  is  mapped  to 
screen positions.  There  are  basicly  two  ways of mapping the complex 
plane to screen co-ordinates, namely

   1) Map a finite region of the complex plane to the screen.

   2) Map the whole, infinite, complex plane to a finite region.

The second of these obviously involves severe distortion, but it has the
big advantage of covering the whole of the complex realm.  A  number  of
different ways of perfoming this mapping are provided and are selectable 
using the DomainMapMode parameter and they may  be  modified  using  the
other DomainMap parameters.

Note, for those mappings that map the whole of the infinte complex plane
plane to a finite region of the screen the areas of the screen that  lie
outside of that area correspond to stretched copies of the main area. As
always refer to the comments in the shader's sources for details.

Orthogonaly to this dichotomy, but also controlled by DomainMapMode,  is
whether the mapping is direct, which maps (0.0,0.0) to  itself  and  the
points at infinity either to points at infinity or to  the  boundary  of 
the finite region used for the mapped domain, or is inverting which maps
the points at infinity to (0.0,0.0) and (0.0,0.0) either to  the  points
at infinity or to the boundary of the finite region used for the  mapped
domain (some minor variations on these are also possible). In the first,
direct,  case  the area near the unmapped origin remains in place and is
almost undistorted while in the second,  inverting,  case  this  area is
replaced by those parts of the unmapped domain "near" infinity  allowing
a clear view of the farthest reaches of the complex plane.  This actualy
makes rather more sense using an alternative interpretation  of  complex
numbers in which they represent points on a sphere with (0.0,0.0) at the
south pole and the points at infinity at the north  pole,  the  southern
hemisphere then corresponds to complex numbers for which R is less  than
1.0 and the northern hemisphere their reciprocals.  With this convention
the direct and inverse mapping correspond to looking at the  south  pole
or at the north pole respectively.

In addition it is possible to "trim" the domain so that only points that
lie within, or only points that lie outside, some rectantangle or elipse 
are considered as part of the functions domain. A typical use of this is
to retain only the primary area of a mapping from the whole of the plane
to a finite area of the screen and discard the copies that surround it.

Any areas that are discard by domain trimming are  rendered   using  the 
colour specified by the TrimColour parameter, defaulting to tranparent.

Primary colouring control
=========================

   uniform int   ColourScheme;
   uniform float ColourPeriod;
   uniform float ColourScale;

These parameters control the main colouring scheme that is used  by  the
shader.  There  are two basic schemes, each with a number of variations,
these being

  1) An internal colouring scheme based directly on the
     value of the function at each point on the screen.

  2) A colouring scheme based on using  the  function's
     value to look up the colour in a texture image.

The first of these produces a set of smoothly coloured images using the
primary and secondary colours,  namely  Red,  Yellow, Green, Cyan, Blue
and Magenta, while the second produces an image containing multiple but
distorted copies of the image used as the texture.

In both cases the image can be animated by providing a  non-zero  value
for the ColourPeriod.

Contour line control
====================

   uniform int   ContourMode;
   uniform vec4  ContourPowerScale;
   uniform vec4  ContourDensity;
   uniform vec4  ContourDamping;
   uniform vec2  ContourSharpness;
   uniform vec2  ContourFadeRate;

If the internal colouring scheme is used then  by  default  it  will  be
overlain by a two sets of contour lines representing "unit steps" in the
(x,y) and (R,theta) representations of the function's result, though the
theta contours are suppressed by default.  This  set of parameter allows
the way in which these contours are displayed to be controlled.  See the
comments in the shader's source for details.

Note, form most values of ContourMode the "unit steps" do not correspond
to unit steps in the actual value of the function but to its value after
being re-mapped according to the ContourMode,  which  in most cases is a
sigmoid, S shaped, function of some sort  that  reduces  the  potentialy
infinite ranges of the function result's x, y an R  components  to  some
finite range - which greatly improves the appearance of the contours for
large values of the original function results,  mainly  by not having to
cram in a large number of them in a small area of he screen. The details
of this are described in comments in the shader's source.

Misc colour control
===================

   uniform vec4  NanColour;
   uniform float Translucency;

If a function result can not be calculated, e.g. because of encountering
a mathematical problem such as trying to  calculate  0.0/0.0,  then  its
value will have the special case floating point value of NaN for one  or
both of its components. This special value means Not A Number and it can
not be interpreted as a real number.  When this occurs the corresponding
point on the screen is rendered using the NanColour  which  defaults  to
transparent.  Any  large black areas in the final image that are not due
to domain trimming can be attributed to encountering a NaN.

By default,  except for those areas rendered in the TrimColour or in the 
NanColour, the image will be opaque.  This can be modified by specifying
a non-zero value for Translucency with 0.0 corresponding to fully opaque
and 1.0 to fully transparent.

Data panel control
==================

   uniform int   DataPanel;
   uniform vec4  DataPanelCycle;

These parameters control the optional data panel,  the  first being used
to enable or disable it and the second to control when it fades into and
out of visibility. Refer to the comments in the shader's source file for
details of how to use these parameters and to the 

    "File names and the data panel"

text file for how to interpret it.
