Puppeteer 1.2

Short:        CyberGL model viewer with Inverse Kin.
Author:       progers@undergrad.math.uwaterloo.ca (Patrick Rogers)
Uploader:     progers undergrad math uwaterloo ca (Patrick Rogers)
Type:         gfx/show
Version:      1.2
Architecture: m68k-amigaos

                              Introduction

   Puppeteer is a port of my graphics project for cs488 at the university of 
Waterloo.  I invested a lot of time in this project (or rather I invested a 
lot of sleepless hours during a brief 2-3 week period) and wanted to clean up 
the code and some of the bugs, as well as perform some experiments with the 
system I developed.

   Another reason for doing the port was to experiment with CyberGL, to see 
how full an implementation of OpenGL it was, and how well it worked. The 
documentation in the developer distribution for CyberGL was rather sparse and 
I have not seen any programs that use CyberGL other than the demos supplied 
with the archive (and they were pretty straightforward).

   It seems that every software product that Phase5 is associated with is 
shrouded in controversy.  This demo probably wouldn't be enhanced by a version
of CyberGL for the Cybervision64/3D (since it uses no texture mapping and this
seems to be the main function of the VIRGE chipset) but it should take 
advantage of a PowerPC version of CyberGL and a version of CyberGL optimized 
for the CybervisionPPC card (or any other 3D graphics card for the Amiga that 
was supported by CyberGL).  I hoped that by writing this I would be able to 
have something that could run fast on my PPC card when I purchased it.  (And 
that other people would have a demo that showed how much faster CyberGL was on
their PPC).

                             Description

   Puppeteer is a model viewer that displays articulated hierarchical 
models and allows the user to manipulate them using an inverse kinematics 
system. A hierarchical model is a model that consists of a set of primitives 
positioned relative to each other.  Forward kinematics is the manipulation of 
such a system by specifying the angle of each joint.  This makes it difficult 
to specify simple configurations of the system intuitively.  (Forward 
kinematics was the assignment that the project was based on).  Inverse 
kinematics is the manipulation of a hierarchical system by specifying goal 
configurations for primitives and solving for the joint angles that yield the 
goal.

   Puppeteer uses the inverse kinematics to implement gravity and wind based 
animations.  You can manipulate the model and watch the effects of wind and 
gravity on it.  I have supplied several sample models, and more can be 
created using a text editor (and a lot of patience).

                               Changes Since 1.1

   · Implemented Hierachical meshes.  These meshes bend with the joints
     contained within them.  They are a bit of a hack, however.
   · Implemented mesh primitives.  These are solid triangle meshes defined
     via contours.
   · Made the material class into a proper object with methods and private 
     members.  Added texture mapped materials.
   · Expanded the command parser to be able to handle nested parentheses and
     commands with variable numbers of arguments.
   · Added a default value for a joint when setting it's constraints.
   · Created the dino object to demonstrate the new features.  Also created
     the slug and worm objects.
   · Added fast move option to animate menu to enable wireframe while the
     model is being manipulated.
   · Reduced stack usage.
   · Compiled versions of Puppeteer for 040 and 060 processors.


                                Requirements
                                   
   Puppeteer requires an 030 and an FPU.  It also requires OS 2.04 and CyberGL
library V39.11 (Plus all requirements for running CyberGL).

   I'm not sure what screenmodes Puppeteer will work on, because the CyberGL
documentation doesn't specify the screenmode restrictions.  The web page says
ECS is supported, but I wasn't able to open a window on an ECS screen.  
Perhaps RGBA mode cannot be used on ECS but I am not sure, since it is not
documented.  So it may or may not work on 8 bit AGA screens.  Personally, I 
always run at 16 bit, because this gives the best tradeoff between 
performance and appearance on my Picasso II.