This commit was generated by cvs2svn to compensate for changes in r2,

which included commits to RCS files with non-trunk default branches.

2 files changed, 3481 insertions, 0 deletions

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..a9d9197
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,56 @@
+#
+#    xstar - Simple X based yale.star viewer
+#
+#    Copyright (C) 2002  Ian Cowburn (ianc@noddybox.demon.co.uk)
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#    -------------------------------------------------------------------------
+#
+
+
+TARGET	=	xd
+
+SOURCES	=	$(TARGET).c
+
+HEADERS	=
+
+OBJECTS	=	$(SOURCES:.c=.o)
+
+LIBS	=	-lX11 -lm
+
+FLAGS	=	-g -I/usr/X11R6/include -L/usr/X11R6/lib
+
+DEPEND	=	depend.mak
+
+$(TARGET): $(OBJECTS)
+	$(CC) $(FLAGS) -o $(TARGET) $(OBJECTS) $(LIBS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) $(FLAGS) $(TRACE) -c $< -o $@
+
+-include depend.mak
+
+clean:
+	-rm $(TARGET) $(TARGET).exe core *.stackdump *.o depend.mak
+
+depend: $(DEPEND)
+	@echo Dependencies updated....
+
+$(DEPEND): $(SOURCES) $(HEADERS)
+	$(CC) $(FLAGS) -MM $(SOURCES) > $(DEPEND)
+
+
+# END OF FILE
diff --git a/xd.c b/xd.c
new file mode 100644
index 0000000..cc2502f
--- /dev/null
+++ b/xd.c
@@ -0,0 +1,3425 @@
+/*
+
+    xd - X11 demo framefork
+
+    Copyright (C) 2002  Ian Cowburn (ianc@noddybox.demon.co.uk)
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    -------------------------------------------------------------------------
+
+*/
+static const char id[]="$Id$";
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+
+/* ---------------------------------------- HANDY MACROS
+*/
+#ifndef TRUE
+#define TRUE True
+#endif
+
+#ifndef FALSE
+#define FALSE False
+#endif
+
+#ifndef M_PI
+# define M_PI 3.14159265358979323846
+#endif
+
+#define RAD(x)  ((x)*M_PI/180.0)
+
+#define MIN(a,b)	((a)<(b)?(a):(b))
+#define MAX(a,b)	((a)>(b)?(a):(b))
+
+#define LIMIT(v,m,l)	MIN((m),MAX((v),(l)))
+
+#define RND(x)		(rand()%(x))
+#define RND2(h,l)	((rand()%((h)-(l)))+(l))
+
+/* ---------------------------------------- TYPES
+*/
+typedef enum {UsesImage, UsesPixmap} DType;
+
+typedef enum {MousePress, MouseRelease, MouseMove} Mouse;
+
+typedef struct
+	{
+	const char	*name;
+	void		(*draw)(void);
+	DType		type;
+	} DemoInfo;
+
+typedef struct
+	{
+	double	x,y,z;
+	} Point3D;
+
+#define MAX_POLY_POINTS	32
+
+typedef struct
+	{
+	int	p[MAX_POLY_POINTS];
+	int	no;
+	int	col;
+	} Poly3D;
+
+typedef struct
+	{
+	int		no_points;
+	int		no_poly;
+
+	Point3D		origin;
+
+	Point3D		*ps;
+	Poly3D		*poly;
+
+	Point3D		*workp3;
+	XPoint		*workxp;
+
+	int		x_rot;
+	int		y_rot;
+	int		z_rot;
+
+	int		mode;
+
+	int		col;
+
+	int		cull;
+	} Obj3D;
+
+#define MODE_SOLID	0
+#define MODE_WIRE	1
+#define MODE_EDGE	2
+
+typedef struct
+	{
+	Point3D		origin;
+	int		radius;
+	int		mode;
+	unsigned long	col;
+	} Sphere3D;
+
+typedef struct
+	{
+	Point3D		origin;
+	int		w,h;
+	int		mode;
+	unsigned long	col;
+	} Rect3D;
+
+typedef struct
+	{
+	Point3D		origin;
+	unsigned long	col;
+	} Particle3D;
+
+typedef enum {eObj, eSphere, eRect, eParticle} ObjType;
+
+typedef struct
+	{
+	ObjType		type;
+	void		*p;
+	} WorldObj;
+
+/* ---------------------------------------- DEMO PROTOS
+*/
+static void	AutoDropDemo(void);
+static void	DropDemo(void);
+static void	FastDropDemo(void);
+static void	TrailDemo(void);
+static void	TunnelDemo(void);
+static void	StarDemo(void);
+static void	StarSphereDemo(void);
+static void	Test3DDemo(void);
+static void	ColScapeDemo(void);
+static void	FluidDemo(void);
+static void	ParticleDropDemo(void);
+static void	PolyDropDemo(void);
+static void	CraterDemo(void);
+static void	TriangleDemo(void);
+static void	TriangleDemo2(void);
+
+/* ---------------------------------------- GLOBAL VARS
+*/
+#define NO_DEMOS	15
+
+static int		demo=NO_DEMOS-1;
+
+static int		cycle=FALSE;
+
+static DemoInfo		demotbl[NO_DEMOS]=
+			{
+			    {
+				"Z-Buffered Pyramids",
+				TrailDemo,
+				UsesPixmap
+			    },
+			    {
+				"Auto Drops",
+				AutoDropDemo,
+				UsesPixmap
+			    },
+			    {
+				"Drops (LMB to drop, RMB to toggle clear)",
+				DropDemo,
+				UsesPixmap
+			    },
+			    {
+				"Fast Drops (LMB to drop, RMB to toggle clear)",
+				FastDropDemo,
+				UsesPixmap
+			    },
+			    {
+				"Tunnel (RMB to toggle clear)",
+				TunnelDemo,
+				UsesPixmap
+			    },
+			    {
+				"Starfield (RMB to toggle warp)",
+				StarDemo,
+				UsesPixmap
+			    },
+			    {
+				"Star Sphere",
+				StarSphereDemo,
+				UsesPixmap
+			    },
+			    {
+				"Test3DDemo",
+				Test3DDemo,
+				UsesPixmap
+			    },
+			    {
+				"Column Landscape",
+				ColScapeDemo,
+				UsesPixmap
+			    },
+			    {
+				"Fluid Particles",
+				FluidDemo,
+				UsesPixmap
+			    },
+			    {
+				"Fluid Drops",
+				ParticleDropDemo,
+				UsesPixmap
+			    },
+			    {
+				"Polygon Water",
+				PolyDropDemo,
+				UsesPixmap
+			    },
+			    {
+				"Crater Landscape",
+				CraterDemo,
+				UsesPixmap
+			    },
+			    {
+				"Triangle Trench",
+				TriangleDemo,
+				UsesPixmap
+			    },
+			    {
+				"Triangle Wavy Trench",
+				TriangleDemo2,
+				UsesPixmap
+			    },
+			};
+
+/* ---------------------------------------- X11 VARS
+*/
+static int			use_root=FALSE;
+static Window			win=None;
+static Pixmap			pix=None;
+static Pixmap			saved=None;
+static GC			gc=None;
+static Display			*disp=NULL;
+static XVisualInfo		visual;
+static XFontStruct		*font=NULL;
+static int			width;
+static int			height;
+static int			centre_x;
+static int			centre_y;
+
+static unsigned long		black;
+static unsigned long		white;
+static unsigned long		red;
+static unsigned long		green;
+static unsigned long		blue;
+
+static int			mouse_x;
+static int			mouse_y;
+static int			mouse_b;
+
+static double			sintab[3600];
+static double			costab[3600];
+
+#define FONTW			(font->max_bounds.rbearing - \
+					font->min_bounds.lbearing)
+#define FONTH			(font->max_bounds.descent + \
+					font->max_bounds.ascent + 1)
+
+/* ---------------------------------------- PROTOS
+*/ 
+static void		OpenX(void);
+
+static unsigned long	GetCol(unsigned long, unsigned long, unsigned long);
+static void		SetCol(unsigned long col);
+
+static void		Cls(void);
+static void		ClsCol(unsigned long col);
+static void		Redraw(void);
+
+static void		UpdateDisplay(void);
+
+static void		Line(int x1,int y1,int x2,int y2,int col);
+static void		LineP(XPoint *p1,XPoint *p2,int col);
+static void		Plot(int x,int y,int col);
+static void		Circle(int x,int y,int r,int col);
+static void		FCircle(int x,int y,int r,int col);
+static void		Print(int x,int y,int col,char *fmt,...);
+static void		Rect(int x,int y,int w,int h,int col);
+static void		FRect(int x,int y,int w,int h,int col);
+static void		Polygon(XPoint pts[], int no, int col);
+static void		FPolygon(XPoint pts[], int no, int col);
+
+static int		AngToCol(int ang, int no_col);
+
+static double		Distance(Point3D *a, Point3D *b);
+
+static int		Project(double x,double y,double z,XPoint *xp);
+static void		RotateX(double cx, double cy, double cz,
+				double ix, double iy, double iz, 
+				double *x, double *y, double *z,
+				int a);
+static void		RotateY(double cx, double cy, double cz,
+				double ix, double iy, double iz, 
+				double *x, double *y, double *z,
+				int a);
+static void		RotateZ(double cx, double cy, double cz,
+				double ix, double iy, double iz, 
+				double *x, double *y, double *z,
+				int a);
+
+static void		DrawObj(Obj3D *o, unsigned long cmap[]);
+
+static void		DrawList(WorldObj *w, int no, unsigned long cmap[],
+				 int inv_z_order, int do_sort);
+static void		DrawSubList(Obj3D *o, int obj_no,
+				    Sphere3D *s, int sphere_no,
+				    Rect3D *r, int rect_no,
+				    Particle3D *p, int particle_no,
+				    unsigned long cmap[],
+				    int inv_z_order, int do_sort);
+
+static void		HandleKey(XKeyEvent *key);
+static void		HandleMouse(int x, int y, int b, Mouse mode);
+
+/* ---------------------------------------- MAIN
+*/
+int main(int argc, char *argv[])
+{
+    XEvent ev;
+    int f;
+
+    for(f=1;f<argc;f++)
+    	{
+	if (!strcmp(argv[f],"-r"))
+	    use_root=TRUE;
+	else if (!strcmp(argv[f],"-c"))
+	    cycle=TRUE;
+	else
+	    {
+	    demo=atoi(argv[f]);
+	    demo=MAX(0,MIN(demo,NO_DEMOS-1));
+	    }
+	}
+
+    OpenX();
+    XMapWindow(disp,win);
+
+    black=GetCol(0,0,0);
+    white=GetCol(255,255,255);
+    red=GetCol(255,0,0);
+    green=GetCol(0,255,0);
+    blue=GetCol(0,0,255);
+
+    for(f=0;f<3600;f++)
+    	{
+	sintab[f]=sin(RAD(f*0.10));
+	costab[f]=cos(RAD(f*0.10));
+	}
+
+    srand(getpid());
+
+    while(TRUE)
+    	{
+	int update;
+
+	if (XPending(disp))
+	    {
+	    XNextEvent(disp,&ev);
+
+	    switch(ev.type)
+		{
+		case KeyPress:
+		    HandleKey(&ev.xkey);
+		    break;
+
+		/*
+		case ButtonPress:
+		    HandleMouse(ev.xbutton.x,ev.xbutton.y,
+				ev.xbutton.button,MousePress);
+		    break;
+
+		case ButtonRelease:
+		    HandleMouse(ev.xbutton.x,ev.xbutton.y,
+				ev.xbutton.button,MouseRelease);
+		    break;
+
+		case MotionNotify:
+		    HandleMouse(ev.xbutton.x,ev.xbutton.y,
+				ev.xbutton.button,MouseMove);
+		    break;
+
+		case Expose:
+		    if (ev.xexpose.count==0)
+			Redraw();
+
+		    break;
+		*/
+
+		default:
+		    break;
+		}
+	    }
+
+	{
+	Window w1,w2;
+	int i1,i2;
+
+	XQueryPointer(disp,win,&w1,&w2,&i1,&i2,&mouse_x,&mouse_y,&mouse_b);
+	}
+
+	demotbl[demo].draw();
+	Redraw();
+	}
+
+    return EXIT_SUCCESS;
+}
+
+
+/* ---------------------------------------- UTILS
+*/
+static void Error(char *p)
+{
+    fprintf(stderr,"%s\n",p);
+    exit(EXIT_FAILURE);
+}
+
+static void *Grab(size_t s)
+{
+    void *p;
+
+    if (!(p=malloc(s)))
+    	Error("malloc()");
+
+    return p;
+}
+
+
+static void Release(void *p)
+{
+    free(p);
+}
+
+
+static void Bounce(int *x, int *y, int *ix, int *iy)
+{
+    *x+=*ix;
+    *y+=*iy;
+
+    if (*x<0 || *x>=width)
+    	{
+	*ix=-(*ix);
+	*x+=*ix;
+	}
+
+    if (*y<0 || *y>=height)
+    	{
+	*iy=-(*iy);
+	*y+=*iy;
+	}
+}
+
+
+/* ---------------------------------------- X11 UTILS
+*/
+static void OpenX(void)
+{
+    XGCValues gc_val;
+    XSizeHints hint;
+    int f;
+
+    /* Open display and find an appropriate visual
+    */
+    if (!(disp=XOpenDisplay(NULL)))
+	Error("Couldn't open X display");
+
+    if (!XMatchVisualInfo(disp,DefaultScreen(disp),32,TrueColor,&visual) &&
+	!XMatchVisualInfo(disp,DefaultScreen(disp),24,TrueColor,&visual) &&
+	!XMatchVisualInfo(disp,DefaultScreen(disp),16,TrueColor,&visual) &&
+	!XMatchVisualInfo(disp,DefaultScreen(disp),15,TrueColor,&visual))
+	    Error("Couldn't find a visual\n");
+
+    font=XLoadQueryFont(disp,"fixed");
+
+    if (!font)
+	Error("Couldn't load font fixed");
+
+    width=640;
+    height=480;
+
+    if (!use_root)
+	win=XCreateWindow(disp,DefaultRootWindow(disp),
+			  0,0,width,height,0,
+			  visual.depth,
+			  InputOutput,
+			  visual.visual,
+			  0,NULL);
+    else
+	{
+    	win=DefaultRootWindow(disp);
+	width=DisplayWidth(disp,DefaultScreen(disp));
+	height=DisplayHeight(disp,DefaultScreen(disp));
+	}
+
+    centre_x=width/2;
+    centre_y=height/2;
+    
+    /*
+    XSelectInput
+    	(disp,win,
+	 KeyPressMask|ButtonPressMask|ButtonReleaseMask|
+	 	PointerMotionMask|ExposureMask);
+    */
+    XSelectInput(disp,win,KeyPressMask);
+
+    XStoreName(disp,win,demotbl[demo].name);
+
+    hint.width=hint.min_width=hint.max_width=width;
+    hint.height=hint.min_height=hint.max_height=height;
+    hint.flags=PSize|PMinSize|PMaxSize;
+
+    XSetWMNormalHints(disp,win,&hint);
+
+    pix=XCreatePixmap(disp,win,width,height,visual.depth);
+    saved=XCreatePixmap(disp,win,width,height,visual.depth);
+
+    gc_val.function=GXcopy;
+    gc_val.plane_mask=AllPlanes;
+    gc_val.line_width=0;
+    gc_val.line_style=LineSolid;
+    gc_val.graphics_exposures=False;
+    gc_val.foreground=WhitePixel(disp,DefaultScreen(disp));
+    gc_val.background=BlackPixel(disp,DefaultScreen(disp));
+
+    gc=XCreateGC(disp,pix,
+		 GCFunction|GCPlaneMask|GCLineWidth|GCForeground|GCBackground|
+		 	GCLineStyle|GCGraphicsExposures,
+		 &gc_val);
+
+    if (use_root)
+	{
+	/*
+	XSetCloseDownMode(disp,RetainTemporary);
+	XSetWindowBackgroundPixmap(disp,win,pix);
+	*/
+	}
+
+
+    /* TODO: XImage creation */
+
+    Cls();
+    Redraw();
+}
+
+
+static void Cls()
+{
+    SetCol(black);
+    XFillRectangle(disp,pix,gc,0,0,width,height);
+}
+
+
+static void ClsCol(unsigned long col)
+{
+    SetCol(col);
+    XFillRectangle(disp,pix,gc,0,0,width,height);
+}
+
+
+static void Redraw(void)
+{
+    if (demotbl[demo].type==UsesPixmap)
+	XCopyArea(disp,pix,win,gc,0,0,width,height,0,0);
+    else
+    	{
+	/* TODO: XImage copy */
+	}
+    /* XFlush(disp); */
+    XSync(disp,FALSE);
+}
+
+
+static void Line(int x1,int y1,int x2,int y2,int col)
+{
+    SetCol(col);
+    XDrawLine(disp,pix,gc,x1,y1,x2,y2);
+}
+
+
+static void LineP(XPoint *p1, XPoint *p2, int col)
+{
+    SetCol(col);
+    XDrawLine(disp,pix,gc,p1->x,p1->y,p2->x,p2->y);
+}
+
+
+static void Plot(int x,int y,int col)
+{
+    SetCol(col);
+    XDrawPoint(disp,pix,gc,x,y);
+}
+
+
+static void Circle(int x,int y,int r,int col)
+{
+    if (r<1)
+    	{
+	Plot(x,y,col);
+	return;
+	}
+
+    SetCol(col);
+    XDrawArc(disp,pix,gc,x-r,y-r,r*2,r*2,0,64*360);
+}
+
+
+static void FCircle(int x,int y,int r,int col)
+{
+    if (r<1)
+    	{
+	Plot(x,y,col);
+	return;
+	}
+
+    SetCol(col);
+    XFillArc(disp,pix,gc,x-r,y-r,r*2,r*2,0,64*360);
+}
+
+
+static void Print(int x,int y,int col,char *fmt,...)
+{
+    char s[1024];
+    va_list va;
+    size_t len;
+
+    va_start(va,fmt);
+    vsprintf(s,fmt,va);
+    va_end(va);
+
+    len=strlen(s);
+
+    y+=FONTH-1;
+
+    SetCol(col);
+    XDrawString(disp,pix,gc,x,y,s,len);
+}
+
+
+static void Rect(int x,int y,int w,int h,int col)
+{
+    if (w==0 && h==0)
+	{
+	Plot(x,y,col);
+	return;
+	}
+
+    SetCol(col);
+    XDrawRectangle(disp,pix,gc,x,y,w,h);
+}
+
+
+static void FRect(int x,int y,int w,int h,int col)
+{
+    if (w==0 && h==0)
+	{
+	Plot(x,y,col);
+	return;
+	}
+
+    SetCol(col);
+    XFillRectangle(disp,pix,gc,x,y,w,h);
+}
+
+
+static void Polygon(XPoint p[], int no, int col)
+{
+    int f;
+
+    for(f=0;f<no;f++)
+    	LineP(p+f,p+(f+1)%no,col);
+}
+
+
+static void FPolygon(XPoint pts[], int no, int col)
+{
+    SetCol(col);
+    XFillPolygon(disp,pix,gc,pts,no,Nonconvex,CoordModeOrigin);
+}
+
+
+static unsigned long GetCol(unsigned long r, unsigned long g, unsigned long b)
+{
+    XColor pix;
+
+    pix.red=(r<<8)|(r?0xff:0);
+    pix.green=(g<<8)|(g?0xff:0);
+    pix.blue=(b<<8)|(b?0xff:0);
+    pix.flags=DoRed|DoBlue|DoGreen;
+
+    XAllocColor(disp,DefaultColormap(disp,DefaultScreen(disp)),&pix);
+ 
+    return pix.pixel;
+}
+
+
+static void SetCol(unsigned long col)
+{
+    static unsigned long last_col=123;
+
+    if (col==last_col)
+    	return;
+
+    last_col=col;
+
+    XSetForeground(disp,gc,col);
+}
+
+
+static void HandleKey(XKeyEvent *key)
+{
+    switch(XLookupKeysym(key,0))
+    	{
+	case XK_Prior:
+	    demo--;
+
+	    if (demo<0)
+	    	demo=NO_DEMOS-1;
+
+	    XStoreName(disp,win,demotbl[demo].name);
+	    Cls();
+	    break;
+
+	case XK_Next:
+	    demo=(demo+1)%NO_DEMOS;
+
+	    XStoreName(disp,win,demotbl[demo].name);
+	    Cls();
+	    break;
+
+	default:
+	    break;
+	}
+}
+
+
+static void HandleMouse(int x, int y, int b, Mouse mode)
+{
+    switch(mode)
+    	{
+	case MousePress:
+	    mouse_b|=(1<<(b-1));
+	    break;
+
+	case MouseRelease:
+	    mouse_b&=~(1<<(b-1));
+	    break;
+
+	default:
+	    break;
+	}
+
+    mouse_x=x;
+    mouse_y=y;
+}
+
+
+static int AngToCol(int ang, int no_col)
+{
+    int d;
+
+    if (ang>1800)
+    	ang=1800-(ang-1800);
+
+    d=(int)((no_col/1800.0)*(double)ang);
+
+    return MIN(d,no_col-1);
+}
+
+
+static double Distance(Point3D *a, Point3D *b)
+{
+    double x,y,z;
+
+    x=a->x-b->x;
+    y=a->y-b->y;
+    z=a->z-b->z;
+
+    return sqrt((x*x)+(y*y)+(z*z));
+}
+
+
+static int Project(double x,double y,double z,XPoint *xp)
+{
+    if (z<10.0)
+	return False;
+
+    z=z/800.0;
+
+    xp->x=centre_x+(int)(x/z);
+    xp->y=centre_y+(int)(y/z);
+
+    return True;
+}   
+
+
+static void RotateX(double cx, double cy, double cz,
+		    double ix, double iy, double iz, 
+		    double *x, double *y, double *z,
+		    int a)
+{
+    double dy,dz,si,co;
+
+    while(a<0)
+    	a+=3600;
+
+    a%=3600;
+
+    if (a==0)
+	{
+	*x=ix;
+	*y=iy;
+	*z=iz;
+	return;
+	}
+
+    dy=iy-cy;
+    dz=iz-cz;
+    *x=ix;
+
+    si=sintab[a];
+    co=costab[a];
+
+    *y=cy+(dz*si+dy*co);
+    *z=cz+(dz*co-dy*si);
+}   
+
+
+static void RotateY(double cx, double cy, double cz,
+		    double ix, double iy, double iz, 
+		    double *x, double *y, double *z,
+		    int a)
+{
+    double dx,dz,si,co;
+
+    while(a<0)
+    	a+=3600;
+
+    a%=3600;
+
+    if (a==0)
+	{
+	*x=ix;
+	*y=iy;
+	*z=iz;
+	return;
+	}
+
+    dx=ix-cx;
+    dz=iz-cz;
+    *y=iy;
+
+    si=sintab[a];
+    co=costab[a];
+
+    *x=cy+(dz*si+dx*co);
+    *z=cz+(dz*co-dx*si);
+}   
+
+
+static void RotateZ(double cx, double cy, double cz,
+		    double ix, double iy, double iz, 
+		    double *x, double *y, double *z,
+		    int a)
+{
+    double dy,dx,si,co;
+
+    while(a<0)
+    	a+=3600;
+
+    a%=3600;
+
+    if (a==0)
+	{
+	*x=ix;
+	*y=iy;
+	*z=iz;
+	return;
+	}
+
+    dy=iy-cy;
+    dx=ix-cx;
+    *z=iz;
+
+    si=sintab[a];
+    co=costab[a];
+
+    *y=cy+(dx*si+dy*co);
+    *x=cx+(dx*co-dy*si);
+}   
+
+
+static void DrawObj(Obj3D *o, unsigned long cmap[])
+{
+    int f;
+
+    for(f=0;f<o->no_points;f++)
+    	{
+	RotateX(0,0,0,
+		o->ps[f].x,o->ps[f].y,o->ps[f].z,
+		&o->workp3[f].x,&o->workp3[f].y,&o->workp3[f].z,
+		o->x_rot);
+
+	RotateY(0,0,0,
+		o->workp3[f].x,o->workp3[f].y,o->workp3[f].z,
+		&o->workp3[f].x,&o->workp3[f].y,&o->workp3[f].z,
+		o->y_rot);
+
+	RotateZ(0,0,0,
+		o->workp3[f].x,o->workp3[f].y,o->workp3[f].z,
+		&o->workp3[f].x,&o->workp3[f].y,&o->workp3[f].z,
+		o->z_rot);
+
+	Project(o->origin.x+o->workp3[f].x,
+		o->origin.y+o->workp3[f].y,
+		o->origin.z+o->workp3[f].z,
+		o->workxp+f);
+	}
+
+    for(f=0;f<o->no_poly;f++)
+	{
+	static XPoint p[MAX_POLY_POINTS];
+	int r;
+	int c=-1;
+	int col;
+
+	for(r=0;r<o->poly[f].no;r++)
+	    p[r]=o->workxp[o->poly[f].p[r]];
+
+	if (o->cull)
+	    c=(p[0].x-p[1].x)*(p[2].y-p[1].y)-(p[0].y-p[1].y)*(p[2].x-p[1].x);
+
+	if (o->col!=-1)
+	    col=cmap[o->col];
+	else
+	    col=cmap[o->poly[f].col];
+
+	if (c<0)
+	    switch(o->mode)
+		{
+		case MODE_SOLID:
+		    FPolygon(p,o->poly[f].no,col);
+		    break;
+		case MODE_EDGE:
+		    FPolygon(p,o->poly[f].no,black);
+		    Polygon(p,o->poly[f].no,col);
+		    break;
+		case MODE_WIRE:
+		default:
+		    Polygon(p,o->poly[f].no,col);
+		    break;
+		}
+	}
+}
+
+
+static int ZSort(const void *p1, const void *p2)
+{
+    double z1,z2;
+    const WorldObj *o1, *o2;
+
+    o1=p1;
+    o2=p2;
+
+    switch(o1->type)
+    	{
+	case eObj:
+	    z1=((const Obj3D *)o1->p)->origin.z;
+	    break;
+	case eSphere:
+	    z1=((const Sphere3D *)o1->p)->origin.z;
+	    break;
+	case eRect:
+	    z1=((const Rect3D *)o1->p)->origin.z;
+	    break;
+	case eParticle:
+	    z1=((const Particle3D *)o1->p)->origin.z;
+	    break;
+	default:
+	    z1=-1;
+	    break;
+	}
+
+    switch(o2->type)
+    	{
+	case eObj:
+	    z2=((const Obj3D *)o2->p)->origin.z;
+	    break;
+	case eSphere:
+	    z2=((const Sphere3D *)o2->p)->origin.z;
+	    break;
+	case eRect:
+	    z2=((const Rect3D *)o2->p)->origin.z;
+	    break;
+	case eParticle:
+	    z2=((const Particle3D *)o2->p)->origin.z;
+	    break;
+	default:
+	    z2=-1;
+	    break;
+	}
+
+    return (int)(z2-z1);
+}
+
+
+static int InvZSort(const void *p1, const void *p2)
+{
+    double z1,z2;
+    const WorldObj *o1, *o2;
+
+    o1=p1;
+    o2=p2;
+
+    switch(o1->type)
+    	{
+	case eObj:
+	    z1=((const Obj3D *)o1->p)->origin.z;
+	    break;
+	case eSphere:
+	    z1=((const Sphere3D *)o1->p)->origin.z;
+	    break;
+	case eRect:
+	    z1=((const Rect3D *)o1->p)->origin.z;
+	    break;
+	case eParticle:
+	    z1=((const Particle3D *)o1->p)->origin.z;
+	    break;
+	default:
+	    z1=-1;
+	    break;
+	}
+
+    switch(o2->type)
+    	{
+	case eObj:
+	    z2=((const Obj3D *)o2->p)->origin.z;
+	    break;
+	case eSphere:
+	    z2=((const Sphere3D *)o2->p)->origin.z;
+	    break;
+	case eRect:
+	    z2=((const Rect3D *)o2->p)->origin.z;
+	    break;
+	case eParticle:
+	    z2=((const Particle3D *)o2->p)->origin.z;
+	    break;
+	default:
+	    z2=-1;
+	    break;
+	}
+
+    return (int)(z1-z2);
+}
+
+
+static void DrawList(WorldObj *w, int no, unsigned long cmap[],
+		     int inv_z_order,int do_sort)
+{
+    int f;
+    XPoint xp,xp2;
+    Particle3D *p;
+    Sphere3D *s;
+    Rect3D *r;
+
+    if (do_sort)
+    	{
+	if (inv_z_order)
+	    qsort(w,no,sizeof(WorldObj),InvZSort);
+	else
+	    qsort(w,no,sizeof(WorldObj),ZSort);
+	}
+
+    for(f=0;f<no;f++)
+    	{
+	switch(w[f].type)
+	    {
+	    case eObj:
+		DrawObj(w[f].p,cmap);
+		break;
+
+	    case eSphere:
+		s=w[f].p;
+
+		if (Project(s->origin.x,s->origin.y,s->origin.z,&xp))
+		    if (Project(s->origin.x+s->radius,s->origin.y,
+		    			s->origin.z,&xp2))
+			switch(s->mode)
+			    {
+			    case MODE_SOLID:
+				FCircle(xp.x,xp.y,xp2.x-xp.x,cmap[s->col]);
+				break;
+			    case MODE_WIRE:
+				Circle(xp.x,xp.y,xp2.x-xp.x,cmap[s->col]);
+				break;
+			    case MODE_EDGE:
+				FCircle(xp.x,xp.y,xp2.x-xp.x,black);
+				Circle(xp.x,xp.y,xp2.x-xp.x,cmap[s->col]);
+				break;
+			    }
+		break;
+
+	    case eRect:
+		r=w[f].p;
+
+		if (Project(r->origin.x,r->origin.y,r->origin.z,&xp))
+		    if (Project(r->origin.x+r->w,r->origin.y+r->h,
+		    			r->origin.z,&xp2))
+			{
+			int w,h;
+
+			w=xp2.x-xp.x;
+			h=xp2.y-xp.y;
+
+			switch(r->mode)
+			    {
+			    case MODE_SOLID:
+				FRect(xp.x,xp.y,w,h,cmap[r->col]);
+				break;
+			    case MODE_WIRE:
+				Rect(xp.x,xp.y,w,h,cmap[r->col]);
+				break;
+			    case MODE_EDGE:
+				FRect(xp.x,xp.y,w,h,black);
+				Rect(xp.x,xp.y,w,h,cmap[r->col]);
+				break;
+			    }
+			}
+		break;
+
+	    case eParticle:
+		p=w[f].p;
+
+		if (Project(p->origin.x,p->origin.y,p->origin.z,&xp))
+		    Plot(xp.x,xp.y,cmap[p->col]);
+
+		break;
+
+	    default:
+		break;
+	    }
+	}
+}
+
+
+static void DrawSubList(Obj3D *o, int obj_no,
+			Sphere3D *s, int sphere_no,
+			Rect3D *r, int rect_no,
+			Particle3D *p, int particle_no,
+			unsigned long cmap[], int inv_z_order, int do_sort)
+{
+    WorldObj *w;
+    int no;
+    int f;
+    int i;
+
+    no=obj_no+sphere_no+rect_no+particle_no;
+
+    w=Grab(sizeof(WorldObj)*no);
+
+    i=0;
+
+    for(f=0;f<obj_no;f++,i++)
+    	{
+	w[i].type=eObj;
+	w[i].p=o+f;
+	}
+
+    for(f=0;f<sphere_no;f++,i++)
+    	{
+	w[i].type=eSphere;
+	w[i].p=s+f;
+	}
+
+    for(f=0;f<rect_no;f++,i++)
+    	{
+	w[i].type=eRect;
+	w[i].p=r+f;
+	}
+
+    for(f=0;f<particle_no;f++,i++)
+    	{
+	w[i].type=eParticle;
+	w[i].p=p+f;
+	}
+
+    DrawList(w,no,cmap,inv_z_order,do_sort);
+
+    Release(w);
+}
+
+
+/* ---------------------------------------- EXAMPLE DEMO
+*/
+
+static void ExampleDemo(void)
+{
+    Cls();
+
+    Print(0,20,GetCol(255,255,255),"X: %d  Y:%d  B:%d",mouse_x,mouse_y,mouse_b);
+
+    if (mouse_b&Button1Mask)
+	Line(0,0,mouse_x,mouse_y,GetCol(RND(0xff),RND(0xff),RND(0xff)));
+}
+
+
+/* ---------------------------------------- DROP DEMO
+*/
+static void DropDemo(void)
+{
+    static const int speed=1;
+    static const int scale=1;
+    static int init=FALSE;
+    static int clr=TRUE;
+    static unsigned long col[256];
+    static time_t last=0;
+
+    typedef struct Drop
+    	{
+	int		x,y,r,c;
+	struct Drop	*next;
+	} Drop;
+
+    static Drop *head=NULL;
+    static Drop *tail=NULL;
+
+    Drop *d;
+
+    if (!init)
+    	{
+	int f;
+
+	for(f=0;f<256;f++)
+	    col[f]=GetCol(255-f,255-f,255-f);
+
+	init=TRUE;
+	}
+
+    if (mouse_b&Button3Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    clr=!clr;
+	    bounce=time(NULL);
+	    }
+	}
+
+    if (mouse_b&Button1Mask /*&& (last!=time(NULL))*/)
+	{
+	Drop *new;
+
+	new=Grab(sizeof *new);
+
+	new->x=mouse_x;
+	new->y=mouse_y;
+	new->r=3;
+	new->c=0;
+	new->next=NULL;
+
+	if (!head)
+	    head=tail=new;
+	else
+	    {
+	    tail->next=new;
+	    tail=new;
+	    }
+
+	last=time(NULL);
+	}
+
+    if (clr)
+	Cls();
+
+    d=head;
+
+    while(d)
+    	{
+	if (d->c>=256)
+	    {
+	    Drop *t;
+
+	    if (d->next)
+	    	head=d->next;
+	    else
+	    	head=tail=NULL;
+
+	    t=d;
+	    d=d->next;
+
+	    Release(t);
+	    }
+	else
+	    {
+	    Circle(d->x,d->y,d->r,col[d->c]);
+	    d->r+=scale;
+	    d->c+=speed;
+	    d=d->next;
+	    }
+	}
+}
+
+
+/* ---------------------------------------- AUTO DROP DEMO
+*/
+static void AutoDropDemo(void)
+{
+    static const int speed=1;
+    static const int scale=1;
+    static const int num=10;
+    static int init=FALSE;
+    static unsigned long col[256];
+    static time_t last=0;
+
+    typedef struct Drop
+    	{
+	int		x,y,r,c;
+	int		speed;
+	int		scale;
+	struct Drop	*next;
+	} Drop;
+
+    static Drop *head=NULL;
+    static Drop *tail=NULL;
+
+    Drop *d;
+    int f;
+
+    if (!init)
+    	{
+	int f;
+
+	for(f=0;f<256;f++)
+	    col[f]=GetCol(MAX(255-f*2,0),MAX(255-f*2,0),255-f);
+
+	init=TRUE;
+	}
+
+    if (last!=time(NULL) && !head)
+	{
+	int x,y,sc;
+
+	x=RND(width);
+	y=RND(height);
+	sc=scale;
+
+	for(f=0;f<num;f++)
+	    {
+	    Drop *new;
+
+	    new=Grab(sizeof *new);
+
+	    new->x=x+RND(num);
+	    new->y=y+RND(num);
+	    new->r=3;
+	    new->c=0;
+	    new->scale=sc;
+	    new->speed=speed;
+	    new->next=NULL;
+
+	    if (!head)
+		head=tail=new;
+	    else
+		{
+		tail->next=new;
+		tail=new;
+		}
+	    }
+
+	last=time(NULL);
+	}
+
+    /* Cls(); */
+    d=head;
+
+    while(d)
+    	{
+	if (d->c>=256)
+	    {
+	    Drop *t;
+
+	    if (d->next)
+	    	head=d->next;
+	    else
+	    	head=tail=NULL;
+
+	    t=d;
+	    d=d->next;
+
+	    Release(t);
+	    }
+	else
+	    {
+	    Circle(d->x,d->y,d->r,col[d->c]);
+	    d->r+=d->scale;
+	    d->c+=d->speed;
+	    d=d->next;
+	    }
+	}
+}
+
+
+/* ---------------------------------------- FAST DROP DEMO
+*/
+static void FastDropDemo(void)
+{
+    static const int speed=30;
+    static const int scale=2;
+    static int init=FALSE;
+    static int clr=TRUE;
+    static unsigned long col[256];
+    static time_t last=0;
+
+    typedef struct Drop
+    	{
+	int		x,y,r,c;
+	struct Drop	*next;
+	} Drop;
+
+    static Drop *head=NULL;
+    static Drop *tail=NULL;
+
+    Drop *d;
+
+    if (!init)
+    	{
+	int f;
+
+	for(f=0;f<256;f++)
+	    col[f]=GetCol(255-f,255-f,255-f);
+
+	init=TRUE;
+	}
+
+    if (mouse_b&Button3Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    clr=!clr;
+	    bounce=time(NULL);
+	    }
+	}
+
+    if (mouse_b&Button1Mask /*&& (last!=time(NULL))*/)
+	{
+	Drop *new;
+
+	new=Grab(sizeof *new);
+
+	new->x=mouse_x;
+	new->y=mouse_y;
+	new->r=3;
+	new->c=0;
+	new->next=NULL;
+
+	if (!head)
+	    head=tail=new;
+	else
+	    {
+	    tail->next=new;
+	    tail=new;
+	    }
+
+	last=time(NULL);
+	}
+
+    if (clr)
+	Cls();
+
+    d=head;
+
+    while(d)
+    	{
+	if (d->c>=256)
+	    {
+	    Drop *t;
+
+	    if (d->next)
+	    	head=d->next;
+	    else
+	    	head=tail=NULL;
+
+	    t=d;
+	    d=d->next;
+
+	    Release(t);
+	    }
+	else
+	    {
+	    Rect(d->x-d->r/2,d->y-d->r/2,d->r,d->r,col[d->c]);
+	    d->r+=scale;
+	    d->c+=speed;
+	    d=d->next;
+	    }
+	}
+}
+
+
+/* ---------------------------------------- TRAIL DEMO
+*/
+static void TrailDemo(void)
+{
+    static const int NO=20;
+    static const int speed=20;
+    static const int scale=10;
+    static int init=FALSE;
+    static unsigned long col[256];
+
+    static struct
+    	{
+	int	x,y,xi,yi;
+	} *p;
+
+    typedef struct Drop
+    	{
+	int		x,y,r,c;
+	struct Drop	*next;
+	} Drop;
+
+    static Drop *head=NULL;
+    static Drop *tail=NULL;
+    Drop *new;
+    Drop *d;
+    int f;
+
+    if (!init)
+    	{
+	for(f=0;f<256;f++)
+	    col[f]=GetCol(255-f,255-f,255-f);
+
+	p=Grab(sizeof(*p)*NO);
+
+	for(f=0;f<NO;f++)
+	    {
+	    p[f].x=RND(width);
+	    p[f].y=RND(height);
+
+	    do  {
+		p[f].xi=RND(5)-2;
+		p[f].yi=RND(5)-2;
+		} while (p[f].xi==0 || p[f].yi==0);
+	    }
+
+	init=TRUE;
+	}
+
+    for(f=0;f<NO;f++)
+    	{
+	int r;
+
+	new=Grab(sizeof *new);
+
+	new->x=p[f].x;
+	new->y=p[f].y;
+	new->r=3;
+	new->c=0;
+	new->next=NULL;
+
+	if (!head)
+	    head=tail=new;
+	else
+	    {
+	    tail->next=new;
+	    tail=new;
+	    }
+
+	Bounce(&p[f].x,&p[f].y,&p[f].xi,&p[f].yi);
+	}
+
+    /* Cls(); */
+    d=head;
+
+    while(d)
+    	{
+	if (d->c>=256)
+	    {
+	    Drop *t;
+
+	    if (d->next)
+	    	head=d->next;
+	    else
+	    	head=tail=NULL;
+
+	    t=d;
+	    d=d->next;
+
+	    Release(t);
+	    }
+	else
+	    {
+	    FRect(d->x-d->r/2,d->y-d->r/2,d->r,d->r,col[d->c]);
+	    d->r+=scale;
+	    d->c+=speed;
+	    d=d->next;
+	    }
+	}
+}
+
+
+/* ---------------------------------------- TUNNEL DEMO
+*/
+static void TunnelDemo(void)
+{
+    static const int speed=100;
+    static const int radius=1000;
+    static const int points=10;
+    static const int max_z=50000;
+    static const int delay=20;
+
+    static double *si;
+    static double *co;
+
+    static int init=FALSE;
+    static int clr=TRUE;
+    static unsigned long col[256];
+    static time_t last=0;
+    static int create=0;
+
+    typedef struct Drop
+    	{
+	double		x[points];
+	double		y[points];
+	double		z;
+	int		r,c;
+	int		ang;
+	struct Drop	*next;
+	} Drop;
+
+    static Drop *head=NULL;
+    static Drop *tail=NULL;
+
+    Drop *d;
+    int f;
+
+    if (!init)
+    	{
+	for(f=0;f<256;f++)
+	    col[f]=GetCol(255-f,255-f,255-f);
+
+	si=Grab(sizeof(double)*points);
+	co=Grab(sizeof(double)*points);
+
+	for(f=0;f<points;f++)
+	    {
+	    si[f]=sin(RAD(360.0/points*f));
+	    co[f]=cos(RAD(360.0/points*f));
+	    }
+
+	init=TRUE;
+	}
+
+    if (mouse_b&Button3Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    clr=!clr;
+	    bounce=time(NULL);
+	    }
+	}
+
+    if (create==0)
+	{
+	Drop *new;
+
+	new=Grab(sizeof *new);
+
+	for(f=0;f<points;f++)
+	    {
+	    new->x[f]=(RND(radius>>1)+radius>>1)*si[f];
+	    new->y[f]=(RND(radius>>1)+radius>>1)*co[f];
+	    }
+
+	new->r=radius;
+	new->z=max_z;
+	new->c=255;
+
+	new->ang=RND(20)-10;
+
+	if (new->ang<0)
+	    new->ang+=3600;
+
+	new->next=NULL;
+
+	if (!head)
+	    head=tail=new;
+	else
+	    {
+	    tail->next=new;
+	    tail=new;
+	    }
+
+	create=delay;
+	}
+    else
+    	create--;
+
+    if (clr)
+	Cls();
+
+    d=head;
+
+    while(d)
+    	{
+	if (d->z<10)
+	    {
+	    Drop *t;
+
+	    if (d->next)
+	    	head=d->next;
+	    else
+	    	head=tail=NULL;
+
+	    t=d;
+	    d=d->next;
+
+	    Release(t);
+	    }
+	else
+	    {
+	    XPoint p[points];
+
+	    if (d->c)
+		d->c=MAX(0,d->c-10);
+
+	    for(f=0;f<points;f++)
+		{
+		RotateZ(0,0,d->z,
+			d->x[f],d->y[f],d->z,
+			&d->x[f],&d->y[f],&d->z,
+			d->ang);
+
+		Project(d->x[f],d->y[f],d->z,p+f);
+		}
+
+	    for(f=0;f<points;f++)
+		LineP(p+f,p+((f+1)%points),col[d->c]);
+
+	    d->z-=speed;
+	    d=d->next;
+	    }
+	}
+}
+
+
+/* ---------------------------------------- STAR DEMO
+*/
+static void StarDemo(void)
+{
+#   define TYPE Particle3D
+#   undef ISSPHERE
+
+    static const int no_points=4;
+    static const int no_poly=4;
+
+    static Point3D pset[4]=
+    			{
+			    {-100,50,100},
+			    {100,50,100},
+			    {0,-50,100},
+			    {0,0,-300},
+			};
+
+    static Poly3D plist[4]=
+    			{
+			    {
+				{0,3,1},
+				3,
+				0
+			    },
+			    {
+				{0,1,2},
+				3,
+				0
+			    },
+			    {
+				{0,2,3},
+				3,
+				0
+			    },
+			    {
+				{1,3,2},
+				3,
+				0
+			    },
+			};
+
+    static Obj3D *obj;
+
+#ifdef ISSPHERE
+    static const int no=200;
+#else
+    static const int no=2000;
+#endif
+
+    static const int no_obj=3;
+    static const int radius=25000;
+    static const int max_z=50000;
+    static const double max_speed=50.0;
+    static const double min_speed=1.0;
+    static const double speed_inc=0.1;
+
+    static int init=FALSE;
+    static unsigned long col[256];
+    static int clr=TRUE;
+    static time_t last=0;
+    static double speed=1.0;
+
+    static TYPE *star;
+    int fg,bg;
+    int f;
+
+    if (!init)
+    	{
+	for(f=0;f<256;f++)
+	    col[f]=GetCol(255-f,255-f,255-f);
+
+	star=Grab(sizeof(TYPE)*no);
+
+	for(f=0;f<no;f++)
+	    {
+	    star[f].origin.x=RND(radius)-radius/2;
+	    star[f].origin.y=RND(radius)-radius/2;
+	    star[f].origin.z=RND(max_z);
+
+#	    if defined(ISSPHERE)
+	    star[f].radius=100;
+	    star[f].mode=MODE_EDGE;
+#	    endif
+	    star[f].col=255;
+	    }
+
+	obj=Grab(sizeof(Obj3D)*no_obj);
+
+	for(f=0;f<no_obj;f++)
+	    {
+	    obj[f].no_points=no_points;
+	    obj[f].no_poly=no_poly;
+	    obj[f].ps=pset;
+	    obj[f].poly=plist;
+	    obj[f].workp3=Grab(sizeof(Point3D)*no_points);
+	    obj[f].workxp=Grab(sizeof(XPoint)*no_points);
+	    obj[f].x_rot=0;
+	    obj[f].y_rot=0;
+	    obj[f].z_rot=RND(3600);
+	    obj[f].cull=True;
+	    obj[f].mode=MODE_EDGE;
+
+	    obj[f].origin.x=RND(radius/8)-radius/16;
+	    obj[f].origin.y=RND(radius/8)-radius/16;
+	    obj[f].origin.z=RND(radius);
+
+	    obj[f].col=255;
+	    }
+
+	init=TRUE;
+	}
+
+    if (mouse_b&Button3Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    clr=!clr;
+	    bounce=time(NULL);
+	    }
+	}
+
+    if (!clr)
+    	{
+	if (speed<max_speed)
+	    speed+=speed_inc;
+	}
+    else
+    	{
+	if (speed>min_speed)
+	    speed-=speed_inc;
+	}
+
+    Cls();
+
+    for(f=0;f<no;f++)
+    	{
+	if (star[f].origin.z<1000)
+	    {
+	    star[f].origin.x=RND(radius)-radius/2;
+	    star[f].origin.y=RND(radius)-radius/2;
+	    star[f].origin.z=max_z;
+	    star[f].col=255;
+	    }
+	else
+	    {
+	    /*
+	    RotateZ(0,0,0,
+		    star[f].origin.x,star[f].origin.y,star[f].origin.z,
+		    &star[f].origin.x,&star[f].origin.y,&star[f].origin.z,
+		    1);
+	    */
+
+	    if (speed>min_speed)
+		{
+		XPoint p;
+		XPoint p2;
+
+		Project(star[f].origin.x,star[f].origin.y,star[f].origin.z,&p);
+		Project(star[f].origin.x,star[f].origin.y,star[f].origin.z+speed*speed,&p2);
+		LineP(&p,&p2,col[star[f].col]);
+		}
+
+	    star[f].origin.z-=20*speed;
+
+	    if (star[f].col)
+	    	star[f].col--;
+	    }
+	}
+
+    for(f=0;f<no_obj;f++)
+    	{
+	obj[f].origin.z-=100*speed;
+	obj[f].z_rot+=10;
+
+	if (obj[f].col)
+	    obj[f].col=MAX(0,obj[f].col-speed);
+
+	if (obj[f].origin.z<400)
+	    {
+	    obj[f].origin.x=RND(radius/8)-radius/16;
+	    obj[f].origin.y=RND(radius/8)-radius/16;
+	    obj[f].origin.z=radius*2;
+	    obj[f].col=255;
+	    }
+	}
+
+#   if defined(ISSPHERE)
+	DrawSubList(obj,no_obj,star,no,NULL,0,NULL,0,col,False,True);
+#   else
+	DrawSubList(obj,no_obj,NULL,0,NULL,0,star,no,col,False,True);
+#   endif
+}
+
+
+/* ---------------------------------------- STAR SPHERE DEMO
+*/
+static void StarSphereDemo(void)
+{
+    static const int no=100;
+    static const int radius=25000;
+    static const int max_z=100000;
+    static const int base_speed=20;
+    static const int sphere_radius=500;
+    static const double max_speed=50.0;
+    static const double min_speed=1.0;
+    static const double speed_inc=0.1;
+
+    static int init=FALSE;
+    static unsigned long col[256];
+    static int clr=TRUE;
+    static time_t last=0;
+    static double speed=1.0;
+
+    static Sphere3D *star;
+    static WorldObj *wo;
+    int fg,bg;
+    int f;
+
+    if (!init)
+    	{
+	for(f=0;f<256;f++)
+	    col[f]=GetCol(255-f,255-f,255-f);
+
+	star=Grab(sizeof(Sphere3D)*no);
+	wo=Grab(sizeof(WorldObj)*no);
+
+	for(f=0;f<no;f++)
+	    {
+	    star[f].origin.x=RND(radius)-radius/2;
+	    star[f].origin.y=RND(radius)-radius/2;
+	    star[f].origin.z=RND(max_z);
+	    star[f].radius=sphere_radius;
+	    star[f].mode=MODE_EDGE;
+	    star[f].col=255;
+
+	    wo[f].type=eSphere;
+	    wo[f].p=star+f;
+	    }
+
+	init=TRUE;
+	}
+
+    if (mouse_b&Button3Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    clr=!clr;
+	    bounce=time(NULL);
+	    }
+	}
+
+    if (!clr)
+    	{
+	if (speed<max_speed)
+	    speed+=speed_inc;
+	}
+    else
+    	{
+	if (speed>min_speed)
+	    speed-=speed_inc;
+	}
+
+    Cls();
+
+    for(f=0;f<no;f++)
+    	{
+	if (star[f].origin.z<1000)
+	    {
+	    star[f].origin.x=RND(radius)-radius/2;
+	    star[f].origin.y=RND(radius)-radius/2;
+	    star[f].origin.z=max_z;
+	    star[f].col=255;
+	    }
+	else
+	    {
+	    star[f].origin.z-=base_speed*speed;
+
+	    if (star[f].col)
+	    	star[f].col=MAX(0,star[f].col-speed);
+	    }
+	}
+
+    DrawList(wo,no,col,False,True);
+}
+
+
+/* ---------------------------------------- TEST 3D DEMO
+*/
+static void Test3DDemo(void)
+{
+    static const int no_particle=2000;
+    static const int max_z=2000;
+    static const int min_z=500;
+    static const int radius=2000;
+
+    static Point3D pwork[8];
+    static XPoint xpwork[8];
+
+    static Point3D pset[8]=
+    			{
+			    {-50,-200,50},
+			    {50,-200,50},
+			    {50,-200,-50},
+			    {-50,-200,-50},
+
+			    {50,200,50},
+			    {-50,200,50},
+			    {-50,200,-50},
+			    {50,200,-50},
+			};
+
+    static Poly3D plist[6]=
+    			{
+			    {
+				{0,1,2,3},
+				4,
+				0
+			    },
+			    {
+				{4,5,6,7},
+				4,
+				0
+			    },
+			    {
+				{0,5,4,1},
+				4,
+				1
+			    },
+			    {
+				{2,1,4,7},
+				4,
+				2
+			    },
+			    {
+				{3,2,7,6},
+				4,
+				3
+			    },
+			    {
+				{0,3,6,5},
+				4,
+				2
+			    },
+			};
+
+    static Obj3D obj=
+    		{
+		    8,
+		    6,
+		    {0,0,1000},
+		    pset,
+		    plist,
+		    pwork,
+		    xpwork,
+		    0,0,0,
+		    MODE_SOLID,
+		    -1,
+		    True
+		};
+
+    static Particle3D *p;
+    static WorldObj *w;
+
+    static int init=FALSE;
+    static unsigned long col[4];
+    static int rot=0;
+
+    int f;
+
+    if (!init)
+    	{
+	col[0]=white;
+	col[1]=red;
+	col[2]=green;
+	col[3]=blue;
+
+	init=TRUE;
+
+	p=Grab(sizeof(Particle3D)*no_particle);
+	w=Grab(sizeof(WorldObj)*(no_particle+1));
+
+	for(f=0;f<no_particle;f++)
+	    {
+	    p[f].origin.x=RND(radius*2)-radius;
+	    p[f].origin.y=RND(radius*2)-radius;
+	    p[f].origin.z=RND(max_z-min_z)+min_z;
+	    if (RND(2)==1)
+		p[f].origin.z=max_z;
+	    else
+		p[f].origin.z=min_z;
+	    p[f].col=0;
+	    w[f].p=p+f;
+	    w[f].type=eParticle;
+	    }
+
+	w[no_particle].type=eObj;
+	w[no_particle].p=&obj;
+
+	DrawList(w,no_particle+1,col,False,True);
+	}
+
+    if (mouse_b&Button2Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    rot=(rot+1)%3;
+	    bounce=time(NULL);
+	    }
+	}
+
+    if (mouse_b&Button3Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    obj.cull=!obj.cull;
+	    bounce=time(NULL);
+	    }
+	}
+
+    if (mouse_b&Button1Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    obj.mode++;
+
+	    if (obj.mode>MODE_EDGE)
+	    	obj.mode=MODE_SOLID;
+
+	    bounce=time(NULL);
+	    }
+	}
+
+    Cls();
+
+    for(f=0;f<no_particle;f++)
+    	{
+	p[f].origin.y+=1;
+
+	if (p[f].origin.y>radius)
+	    p[f].origin.y=-radius;
+	}
+
+    switch(rot)
+    	{
+	case 0:
+	    Print(0,20,white,"Y rotation");
+	    obj.y_rot+=10;
+	    break;
+	case 1:
+	    Print(0,20,white,"X rotation");
+	    obj.x_rot+=10;
+	    break;
+	case 2:
+	    Print(0,20,white,"Z rotation");
+	    obj.z_rot+=10;
+	    break;
+	default:
+	    break;
+	}
+
+    Print(0,30,white,"Mode : %d   Culling: %s",obj.mode,obj.cull ? "on":"off");
+
+    DrawList(w,no_particle+1,col,False,False);
+}
+
+
+/* ---------------------------------------- COL SCAPE DEMO
+*/
+static void ColScapeDemo(void)
+{
+    static const int gap=200;
+    static const int no_pt=8;
+    static const int no_poly=6;
+    static const int no_x=20;
+    static const int no_z=20;
+    static const int no=400;
+    static const int z_off=1000;
+    static const double y_range=200.0;
+    static const double y_base=100.0;
+
+    static Point3D pset[8]=
+    			{
+			    {-50,-20,50},
+			    {50,-20,50},
+			    {50,-20,-50},
+			    {-50,-20,-50},
+
+			    {50,20,50},
+			    {-50,20,50},
+			    {-50,20,-50},
+			    {50,20,-50},
+			};
+
+    static Poly3D plist[6]=
+    			{
+			    {
+				{0,1,2,3},
+				4,
+				0
+			    },
+			    {
+				{4,5,6,7},
+				4,
+				0
+			    },
+			    {
+				{0,5,4,1},
+				4,
+				0
+			    },
+			    {
+				{2,1,4,7},
+				4,
+				0
+			    },
+			    {
+				{3,2,7,6},
+				4,
+				0
+			    },
+			    {
+				{0,3,6,5},
+				4,
+				0
+			    },
+			};
+
+    static Obj3D *obj;
+
+    static WorldObj *w;
+
+    static int ang=0;
+
+    static int init=FALSE;
+    static unsigned long col[4];
+
+    int f,a;
+
+    if (!init)
+    	{
+	int x,z;
+
+	col[0]=white;
+	col[1]=red;
+	col[2]=green;
+	col[3]=blue;
+
+	init=TRUE;
+
+	obj=Grab(sizeof(Obj3D)*no);
+	w=Grab(sizeof(WorldObj)*no);
+
+	x=-(no_x/2)*gap;
+	z=(no_z)*gap+z_off;
+	a=0;
+
+	for(f=0;f<no;f++)
+	    {
+	    w[f].p=obj+f;
+	    w[f].type=eObj;
+
+	    obj[f].no_points=no_pt;
+	    obj[f].no_poly=no_poly;
+	    obj[f].ps=pset;
+	    obj[f].poly=plist;
+	    obj[f].workp3=Grab(sizeof(Point3D)*no_pt);
+	    obj[f].workxp=Grab(sizeof(XPoint)*no_pt);
+	    obj[f].x_rot=a;
+	    obj[f].y_rot=a;
+	    obj[f].z_rot=0;
+	    obj[f].cull=True;
+	    obj[f].mode=MODE_EDGE;
+
+	    obj[f].origin.x=x;
+	    obj[f].origin.y=0;
+	    obj[f].origin.z=z;
+
+	    obj[f].col=RND(4);
+
+	    x+=gap;
+	    a+=20;
+
+	    if (((f+1)%no_x)==0)
+	    	{
+		x=-(no_x/2)*gap;
+		z-=gap;
+		}
+	    }
+
+	DrawList(w,no,col,False,True);
+	}
+
+    Cls();
+
+    a=ang;
+
+    for(f=0;f<no;f++)
+    	{
+	obj[f].origin.y=y_base+sintab[a]*y_range;
+	obj[f].y_rot+=10;
+	obj[f].x_rot+=10;
+	a=(a+5)%3600;
+	}
+
+    ang=(ang+10)%3600;
+
+    DrawList(w,no,col,False,False);
+}
+
+
+/* ---------------------------------------- FLUID DEMO
+*/
+static void FluidDemo(void)
+{
+    static const int gap=20;
+    static const int no_x=100;
+    static const int no_z=100;
+    static const int no=10000;
+    static const int z_off=300;
+    static const double y_range=30.0;
+    static const double y_base=100.0;
+
+    static unsigned long *col;
+    static Sphere3D *p;
+    static WorldObj *w;
+
+    static int ang=0;
+
+    static int init=FALSE;
+
+    int f,a,a2;
+
+    if (!init)
+    	{
+	int x,z,c;
+
+	col=Grab(sizeof(*col)*no_z);
+
+	for(f=0;f<no_z;f++)
+	    col[f]=GetCol(64,64,255-((no_z-f-1)*2));
+
+	p=Grab(sizeof(Sphere3D)*no);
+	w=Grab(sizeof(WorldObj)*no);
+
+	x=-(no_x/2)*gap;
+	z=(no_z)*gap+z_off;
+	a=0;
+	c=0;
+
+	for(f=0;f<no;f++)
+	    {
+	    w[f].p=p+f;
+	    w[f].type=eSphere;
+
+	    p[f].origin.x=x;
+	    p[f].origin.y=y_base;
+	    p[f].origin.z=z;
+
+	    p[f].radius=gap/2+2;
+	    p[f].col=c;
+	    p[f].mode=MODE_SOLID;
+
+	    x+=gap;
+	    a+=20;
+
+	    if (((f+1)%no_x)==0)
+	    	{
+		x=-(no_x/2)*gap;
+		z-=gap;
+		c++;
+		}
+	    }
+
+	DrawList(w,no,col,False,True);
+
+	init=TRUE;
+	}
+
+    Cls();
+
+    a=ang;
+    a2=ang;
+
+    for(f=0;f<no;f++)
+    	{
+	p[f].origin.y=y_base+(sintab[a]+costab[a])*y_range;
+	a=(a+60)%3600;
+
+	if (((f+1)%no_x)==0)
+	    {
+	    a2=(a2+60)%3600;
+	    a=a2;
+	    }
+	}
+
+    ang=(ang+60)%3600;
+
+    DrawList(w,no,col,False,False);
+}
+
+
+/* ---------------------------------------- PARTICLE DROP DEMO
+*/
+static void ParticleDropDemo(void)
+{
+    static const int gap=30;
+    static const int radius=17;
+    static const int no_x=50;
+    static const int no_z=50;
+    static const int no=2500;
+    static const int z_off=300;
+    static const double y_range=30.0;
+    static const double y_base=100.0;
+    static const double drop_y=-1000;
+    static const double drop_speed=10;
+    static const double init_amp=500.0;
+    static const double amp_dropoff=0.5;
+    static const double amp_decay=6.0;
+    static const double ang_dropoff=0.01;
+
+    static int min_x,max_x;
+    static int min_z,max_z;
+
+    static unsigned long *col;
+    static Sphere3D *p;
+    static Sphere3D drop;
+    static WorldObj *w;
+
+    static Point3D ctr;
+
+    static double amp=0.0;
+    static int ang=0;
+    static int dist=0;
+
+    static int init=FALSE;
+
+    int f,a,a2;
+
+    if (!init)
+    	{
+	int x,z,c;
+
+	col=Grab(sizeof(*col)*no_z);
+
+	for(f=0;f<no_z;f++)
+	    col[f]=GetCol(64,64,255-((no_z-f-1)*4));
+
+	p=Grab(sizeof(Sphere3D)*no);
+	w=Grab(sizeof(WorldObj)*(no+1));
+
+	min_x=x=-(no_x/2)*gap;
+	max_z=z=(no_z)*gap+z_off;
+	a=0;
+	c=0;
+
+	for(f=0;f<no;f++)
+	    {
+	    w[f].p=p+f;
+	    w[f].type=eSphere;
+
+	    p[f].origin.x=x;
+	    p[f].origin.y=y_base;
+	    p[f].origin.z=z;
+
+	    p[f].radius=radius;
+	    p[f].col=c;
+	    p[f].mode=MODE_SOLID;
+
+	    x+=gap;
+	    a+=20;
+
+	    if (((f+1)%no_x)==0)
+	    	{
+		max_x=x;
+		x=-(no_x/2)*gap;
+		z-=gap;
+		c++;
+		}
+	    }
+
+	min_z=z;
+
+	max_x/=2;
+	min_x/=2;
+	min_z+=(max_z-min_z)/2;
+
+	w[no].p=&drop;
+	w[no].type=eSphere;
+
+	drop.origin.x=RND2(max_x,min_x);
+	drop.origin.z=RND2(max_z,min_z);
+	drop.origin.y=0;
+
+	drop.radius=gap/2+2;
+	drop.col=0;
+	drop.mode=MODE_SOLID;
+
+	init=TRUE;
+	}
+
+    Cls();
+
+    drop.origin.y+=drop_speed;
+
+    if (drop.origin.y>y_base)
+	{
+	amp=init_amp;
+	ang=0;
+	dist=1;
+	ctr=drop.origin;
+
+	drop.origin.x=RND2(max_x,min_x);
+	drop.origin.z=RND2(max_z,min_z);
+	drop.origin.y=drop_y;
+	}
+
+    if (amp>0.0)
+	{
+	int a;
+
+	if (ang<0)
+	    ang+=3600;
+
+	a=ang;
+
+	for(f=0;f<no;f++)
+	    {
+	    double d;
+	    double y;
+
+	    d=Distance(&ctr,&p[f].origin)/gap;
+
+	    if (d<3.0)
+	    	d=3.0;
+
+	    if (d<dist)
+	    	{
+		y=amp/(d/amp_dropoff);
+		a=(int)(ang+(d/ang_dropoff))%3600;
+	
+		p[f].origin.y=y_base+y*sintab[a];
+		}
+	    }
+
+	amp-=amp_decay;
+	ang-=200;
+	dist++;
+	}
+    else
+	for(f=0;f<no;f++)
+	    p[f].origin.y=y_base;
+
+    DrawList(w,no+1,col,False,True);
+}
+
+
+/* ---------------------------------------- POLY DROP DEMO
+*/
+static void PolyDropDemo(void)
+{
+    static const int gap=30;
+    static const int no_x=50;
+    static const int no_z=50;
+    static const int no=2500;
+    static const int z_off=300;
+    static const double y_range=30.0;
+    static const double y_base=100.0;
+    static const double drop_y=-1000;
+    static const double drop_speed=10;
+    static const double init_amp=500.0;
+    static const double amp_dropoff=2.0;
+    static const double amp_decay=6.0;
+    static const double ang_dropoff=0.01;
+
+    static int min_x,max_x;
+    static int min_z,max_z;
+
+    static unsigned long *col;
+
+    static int no_poly;
+    static Point3D *pt;
+    static Poly3D *poly;
+
+    static Point3D *workp;
+    static XPoint *workxp;
+
+    static Sphere3D drop;
+
+    static Obj3D obj=	
+    		{0,0,{0,0,0},NULL,NULL,NULL,NULL,0,0,0,MODE_EDGE,-1,True};
+
+    static WorldObj w[2];
+
+    static Point3D ctr;
+
+    static double amp=0.0;
+    static int ang=0;
+    static int dist=0;
+
+    static int init=FALSE;
+
+    int f,r;
+
+    if (!init)
+    	{
+	int x,z,c;
+
+	col=Grab(sizeof(*col)*no_z);
+
+	for(f=0;f<no_z;f++)
+	    col[f]=GetCol(64,64,255-((no_z-f-1)*4));
+
+	no_poly=(no_z-1)*(no_x-1);
+
+	pt=Grab(sizeof(Point3D)*no);
+	poly=Grab(sizeof(Poly3D)*no_poly);
+
+	workp=Grab(sizeof(Point3D)*no);
+	workxp=Grab(sizeof(XPoint)*no);
+
+	obj.no_points=no;
+	obj.no_poly=no_poly;
+	obj.ps=pt;
+	obj.poly=poly;
+	obj.workp3=workp;
+	obj.workxp=workxp;
+
+	w[0].p=&obj;
+	w[0].type=eObj;
+	w[1].p=&drop;
+	w[1].type=eSphere;
+
+	min_x=x=-(no_x/2)*gap;
+	max_z=z=(no_z)*gap+z_off;
+
+	for(f=0;f<no;f++)
+	    {
+	    pt[f].x=x;
+	    pt[f].y=y_base;
+	    pt[f].z=z;
+
+	    x+=gap;
+
+	    if (((f+1)%no_x)==0)
+	    	{
+		max_x=x;
+		x=-(no_x/2)*gap;
+		z-=gap;
+		c++;
+		}
+	    }
+
+	min_z=z;
+
+	max_x/=2;
+	min_x/=2;
+	min_z+=(max_z-min_z)/2;
+
+	drop.origin.x=RND2(max_x,min_x);
+	drop.origin.z=RND2(max_z,min_z);
+	drop.origin.y=0;
+
+	drop.radius=gap/2+2;
+	drop.col=0;
+	drop.mode=MODE_SOLID;
+
+	c=0;
+	r=0;
+
+	for(f=0,r=0;f<no_poly;f++,r++)
+	    {
+	    poly[f].col=c;
+	    poly[f].no=4;
+
+	    poly[f].p[0]=r;
+	    poly[f].p[1]=r+1;
+	    poly[f].p[2]=r+1+no_x;
+	    poly[f].p[3]=r+no_x;
+
+	    if (((f+1)%(no_x-1))==0)
+		{
+		c++;
+		r++;
+		}
+	    }
+
+	init=TRUE;
+	}
+
+    Cls();
+
+    drop.origin.y+=drop_speed;
+
+    if (drop.origin.y>y_base)
+	{
+	amp=init_amp;
+	ang=0;
+	dist=1;
+	ctr=drop.origin;
+
+	drop.origin.x=RND2(max_x,min_x);
+	drop.origin.z=RND2(max_z,min_z);
+	drop.origin.y=drop_y;
+	}
+
+    if (amp>0.0)
+	{
+	int a;
+
+	if (ang<0)
+	    ang+=3600;
+
+	a=ang;
+
+	for(f=0;f<no;f++)
+	    {
+	    double d;
+	    double y;
+
+	    d=Distance(&ctr,&pt[f])/gap;
+
+	    if (d<2.0)
+	    	d=2.0;
+
+	    if (d<dist)
+	    	{
+		y=amp/(d/amp_dropoff);
+		a=(int)(ang+(d/ang_dropoff))%3600;
+	
+		pt[f].y=y_base+y*sintab[a];
+		}
+	    }
+
+	amp-=amp_decay;
+	ang-=200;
+	dist++;
+	}
+    else
+	for(f=0;f<no;f++)
+	    pt[f].y=y_base;
+
+    DrawList(w,2,col,False,False);
+}
+
+
+/* ---------------------------------------- CRATER DEMO
+*/
+static void CraterDemo(void)
+{
+    static const int gap=30;
+    static const int no_x=70;
+    static const int no_z=70;
+    static const int no=4900;
+    static const int z_off=300;
+    static const double y_range=30.0;
+    static const double y_base=100.0;
+    static const double drop_y=-100;
+    static const double drop_speed=10;
+    static const double amp_dropoff=0.1;
+    static const double ang_dropoff=0.0035;
+
+    static const double max_dist=10;
+
+    static int min_x,max_x;
+    static int min_z,max_z;
+
+    static unsigned long *col;
+
+    static int no_poly;
+    static Point3D *pt;
+    static Poly3D *poly;
+
+    static Point3D *workp;
+    static XPoint *workxp;
+
+    static Point3D initp;
+
+    static Sphere3D drop;
+
+    static Obj3D obj=	
+    		{0,0,{0,0,0},NULL,NULL,NULL,NULL,0,0,0,MODE_SOLID,-1,True};
+
+    static WorldObj w[2];
+
+    static Point3D ctr;
+
+    static double speed=1.0;
+
+    static int view=FALSE;
+    static int init=FALSE;
+
+    int f,r;
+
+    if (!init)
+    	{
+	int x,z,c;
+
+	col=Grab(sizeof(*col)*no_z);
+
+	initp.x=0;
+	initp.y=y_base;
+	initp.z=z_off+(no_z*gap)/2;
+
+	for(f=0;f<no_z;f++)
+	    col[f]=GetCol(64,64,255-((no_z-f-1)*3));
+
+	no_poly=(no_z-1)*(no_x-1)*2;
+
+	pt=Grab(sizeof(Point3D)*no);
+	poly=Grab(sizeof(Poly3D)*no_poly);
+
+	obj.workp3=Grab(sizeof(Point3D)*no);
+	obj.workxp=Grab(sizeof(XPoint)*no);
+
+	min_x=x=-(no_x/2)*gap;
+	max_z=z=(no_z/2)*gap;
+
+	for(f=0;f<no;f++)
+	    {
+	    pt[f].x=x;
+	    pt[f].y=0;
+	    pt[f].z=z;
+
+	    x+=gap;
+
+	    if (((f+1)%no_x)==0)
+	    	{
+		max_x=x;
+		x=-(no_x/2)*gap;
+		z-=gap;
+		c++;
+		}
+	    }
+
+	min_z=z;
+
+	min_x+=initp.x;
+	max_x+=initp.x;
+	min_z+=initp.z;
+	max_z+=initp.z;
+
+	drop.origin.z=RND2(max_z,min_z)/gap*gap;
+	drop.origin.x=RND2((int)drop.origin.z,(int)-drop.origin.z)/gap*gap;
+	drop.origin.y=0;
+
+	drop.radius=gap/2+2;
+	drop.col=0;
+	drop.mode=MODE_SOLID;
+
+	c=0;
+	r=0;
+
+	for(f=0,r=0;f<no_poly;f+=2,r++)
+	    {
+	    poly[f].col=c;
+	    poly[f].no=3;
+
+	    poly[f].p[0]=r;
+	    poly[f].p[1]=r+1;
+	    poly[f].p[2]=r+no_x;
+
+	    poly[f+1].col=c;
+	    poly[f+1].no=3;
+
+	    poly[f+1].p[0]=r+1;
+	    poly[f+1].p[1]=r+no_x+1;
+	    poly[f+1].p[2]=r+no_x;
+
+	    if (((f+2)%(no_x-1))==0)
+		{
+		r++;
+		c=(c+1)%no_z;
+		}
+	    }
+
+	obj.origin=initp;
+	obj.no_points=no;
+	obj.no_poly=no_poly;
+	obj.ps=pt;
+	obj.poly=poly;
+	obj.workp3=Grab(sizeof(Point3D)*no);
+	obj.workxp=Grab(sizeof(XPoint)*no);
+
+
+	w[0].p=&obj;
+	w[0].type=eObj;
+	w[1].p=&drop;
+	w[1].type=eSphere;
+
+	init=TRUE;
+	}
+
+    if (mouse_b&Button1Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    view=!view;
+
+	    if (!view)
+		{
+		obj.origin=initp;
+		obj.x_rot=0;
+		obj.y_rot=0;
+		obj.z_rot=0;
+		}
+	    else
+	    	obj.origin.z+=800;
+
+	    bounce=time(NULL);
+	    }
+	}
+
+    if (mouse_b&Button3Mask)
+    	{
+	static time_t bounce=0;
+
+	if (bounce!=time(NULL))
+	    {
+	    obj.mode++;
+
+	    if (obj.mode>MODE_EDGE)
+	    	obj.mode=MODE_SOLID;
+
+	    bounce=time(NULL);
+	    }
+	}
+
+    Cls();
+
+    if (view)
+    	{
+	obj.x_rot=MAX(2700,MIN(3599,2700+mouse_y*3));
+
+	obj.y_rot=(centre_x-mouse_x)*3;
+	obj.y_rot=MAX(-900,MIN(obj.y_rot,900));
+	}
+    else
+    	{
+	drop.origin.y+=drop_speed*speed;
+	speed+=0.1;
+
+	if (drop.origin.y>y_base)
+	    {
+	    int a;
+
+	    speed=1.0;
+
+	    ctr=drop.origin;
+
+	    drop.origin.z=RND2(max_z,min_z)/gap*gap;
+	    drop.origin.x=RND2((int)drop.origin.z,(int)-drop.origin.z)/gap*gap;
+	    drop.origin.y=drop_y;
+
+	    for(f=0;f<no;f++)
+		{
+		Point3D p;
+		double d;
+		double y;
+
+		p=pt[f];
+		p.x+=obj.origin.x;
+		p.y+=obj.origin.y;
+		p.z+=obj.origin.z;
+
+		d=Distance(&ctr,&p)/gap;
+
+		if (d<1.0)
+		    d=1.0;
+
+		if (d<max_dist)
+		    {
+		    y=y_range;
+		    a=(int)(900+(d/ang_dropoff))%3600;
+	    
+		    pt[f].y+=y*sintab[a];
+		    }
+		}
+	    }
+	}
+
+    if (view)
+	{
+	DrawObj(&obj,col);
+	Print(0,0,white,"Viewing mode (LMB to end)");
+	}
+    else
+	{
+	DrawList(w,2,col,False,False);
+	DrawSubList(NULL,0,&drop,1,NULL,0,NULL,0,col,FALSE,FALSE);
+	}
+}
+
+
+/* ---------------------------------------- TRIANGLE DEMO
+*/
+static void TriangleDemo(void)
+{
+    static const int gap=100;
+    static const int no_x=6;
+    static const int no_z=100;
+    static const int no=600;
+    static const int z_off=300;
+    static const int no_col=1;
+    static const double y_wall=-500.0;
+    static const double y_range=80.0;
+    static const double y_base=200.0;
+    static const int speed=50;
+
+    static int min_x,max_x;
+    static int min_z,max_z;
+
+    static unsigned long *col;
+
+    static int no_poly;
+    static Point3D *pt;
+    static Poly3D *poly;
+
+    static Point3D *workp;
+    static XPoint *workxp;
+
+    static Point3D initp;
+
+    static Obj3D obj=	
+    		{0,0,{0,0,0},NULL,NULL,NULL,NULL,0,0,0,MODE_EDGE,-1,True};
+
+    static Point3D ctr;
+
+    static int move=0;
+    static int ang=0;
+
+    static int view=FALSE;
+    static int init=FALSE;
+
+    int f,r;
+
+    if (!init)
+    	{
+	int x,z,c;
+
+	col=Grab(sizeof *col * no_col);
+
+	initp.x=0;
+	initp.y=y_base;
+	initp.z=z_off+(no_z*gap)/2;
+
+	for(f=0;f<no_col;f++)
+	    {
+	    int i=255-f;
+	    col[f]=GetCol(i,i,i);
+	    }
+
+	no_poly=(no_z-1)*(no_x-1)*2;
+
+	pt=Grab(sizeof(Point3D)*no);
+	poly=Grab(sizeof(Poly3D)*no_poly);
+
+	obj.workp3=Grab(sizeof(Point3D)*no);
+	obj.workxp=Grab(sizeof(XPoint)*no);
+
+	min_x=x=-(no_x/2)*gap+gap/2;
+	max_z=z=(no_z/2)*gap;
+
+	for(f=0;f<no;f++)
+	    {
+	    int m=f%no_x;
+
+	    pt[f].x=x;
+	    pt[f].z=z;
+
+	    if (m==0 || m==no_x-1)
+		pt[f].y=y_wall;
+	    else
+		pt[f].y=sintab[RND(3600)]*y_range;
+
+	    x+=gap;
+
+	    if (((f+1)%no_x)==0)
+	    	{
+		max_x=x;
+		x=min_x;
+		z-=gap;
+		c++;
+		}
+	    }
+
+	min_z=z;
+
+	min_x+=initp.x;
+	max_x+=initp.x;
+	min_z+=initp.z;
+	max_z+=initp.z;
+
+	r=0;
+
+	for(f=0,r=0;f<no_poly;f+=2,r++)
+	    {
+	    poly[f].col=0;
+	    poly[f].no=3;
+
+	    poly[f].p[0]=r;
+	    poly[f].p[1]=r+1;
+	    poly[f].p[2]=r+no_x;
+
+	    poly[f+1].col=0;
+	    poly[f+1].no=3;
+
+	    poly[f+1].p[0]=r+1;
+	    poly[f+1].p[1]=r+no_x+1;
+	    poly[f+1].p[2]=r+no_x;
+
+	    if (((f+2)%(no_x-1))==0)
+		{
+		r++;
+		c++;
+		}
+	    }
+
+	obj.origin=initp;
+	obj.no_points=no;
+	obj.no_poly=no_poly;
+	obj.ps=pt;
+	obj.poly=poly;
+	obj.workp3=Grab(sizeof(Point3D)*no);
+	obj.workxp=Grab(sizeof(XPoint)*no);
+
+	init=TRUE;
+	}
+
+    Cls();
+    DrawObj(&obj,col);
+
+    ang=(ang+1)%3600;
+
+    move+=speed;
+
+    while (move>=gap)
+    	{
+	for(f=no-1;f>=no_x;f--)
+	    pt[f].y=pt[f-no_x].y;
+
+	for(f=0;f<no_x;f++)
+	    if (f==0 || f==no_x-1)
+		pt[f].y=y_wall;
+	    else
+		pt[f].y=sintab[RND(3600)]*y_range;
+
+	move-=gap;
+	}
+
+    obj.origin.z=initp.z-move;
+}
+
+
+/* ---------------------------------------- TRIANGLE DEMO
+*/
+static void TriangleDemo2(void)
+{
+    static const int gap=100;
+    static const int no_x=6;
+    static const int no_z=100;
+    static const int no=600;
+    static const int z_off=300;
+    static const int no_col=1;
+    static const double y_wall=-500.0;
+    static const double y_range=80.0;
+    static const double y_base=200.0;
+    static const int speed=50;
+
+    static int min_x,max_x;
+    static int min_z,max_z;
+
+    static unsigned long *col;
+
+    static int no_poly;
+    static Point3D *pt;
+    static Poly3D *poly;
+
+    static Point3D *workp;
+    static XPoint *workxp;
+
+    static Point3D initp;
+
+    static Obj3D obj=	
+    		{0,0,{0,0,0},NULL,NULL,NULL,NULL,0,0,0,MODE_EDGE,-1,True};
+
+    static Point3D ctr;
+
+    static int move=0;
+    static int ang=3599;
+    static int angi=1;
+
+    static int view=FALSE;
+    static int init=FALSE;
+
+    int f,r;
+    int newa;
+
+    if (!init)
+    	{
+	int x,z,c;
+
+	col=Grab(sizeof *col * no_col);
+
+	initp.x=0;
+	initp.y=y_base;
+	initp.z=z_off+(no_z*gap)/2;
+
+	for(f=0;f<no_col;f++)
+	    {
+	    int i=255-f*200;
+	    col[f]=GetCol(i/2,i,i/2);
+	    }
+
+	no_poly=(no_z-1)*(no_x-1)*2;
+
+	pt=Grab(sizeof(Point3D)*no);
+	poly=Grab(sizeof(Poly3D)*no_poly);
+
+	obj.workp3=Grab(sizeof(Point3D)*no);
+	obj.workxp=Grab(sizeof(XPoint)*no);
+
+	min_x=x=-(no_x/2)*gap+gap/2;
+	max_z=z=(no_z/2)*gap;
+
+	for(f=0;f<no;f++)
+	    {
+	    int m=f%no_x;
+
+	    pt[f].x=x;
+	    pt[f].z=z;
+
+	    pt[f].y=sintab[ang]*y_range;
+
+	    if (m==0 || m==no_x-1)
+		pt[f].y+=y_wall;
+
+	    x+=gap;
+
+	    if (((f+1)%no_x)==0)
+	    	{
+		max_x=x;
+		x=min_x;
+		z-=gap;
+		c++;
+
+		newa=(ang+angi)%3600;
+
+		if (newa<ang)
+		    {
+		    angi=RND2(450,100);
+		    }
+
+		ang=newa;
+
+		}
+	    }
+
+	min_z=z;
+
+	min_x+=initp.x;
+	max_x+=initp.x;
+	min_z+=initp.z;
+	max_z+=initp.z;
+
+	r=0;
+	c=0;
+
+	for(f=0,r=0;f<no_poly;f+=2,r++)
+	    {
+	    poly[f].col=c;
+	    poly[f].no=3;
+
+	    poly[f].p[0]=r;
+	    poly[f].p[1]=r+1;
+	    poly[f].p[2]=r+no_x;
+
+	    c=(c+1)%no_col;
+
+	    poly[f+1].col=c;
+	    poly[f+1].no=3;
+
+	    poly[f+1].p[0]=r+1;
+	    poly[f+1].p[1]=r+no_x+1;
+	    poly[f+1].p[2]=r+no_x;
+
+	    c=(c+1)%no_col;
+
+	    if (((f+2)%(no_x-1))==0)
+		{
+		r++;
+		}
+	    }
+
+	obj.origin=initp;
+	obj.no_points=no;
+	obj.no_poly=no_poly;
+	obj.ps=pt;
+	obj.poly=poly;
+	obj.workp3=Grab(sizeof(Point3D)*no);
+	obj.workxp=Grab(sizeof(XPoint)*no);
+
+	init=TRUE;
+	}
+
+    Cls();
+    DrawObj(&obj,col);
+
+    newa=(ang+angi)%3600;
+
+    if (newa<ang)
+	{
+	angi=RND2(450,100);
+	}
+
+    ang=newa;
+
+    move+=speed;
+
+    while (move>=gap)
+    	{
+	for(f=no-1;f>=no_x;f--)
+	    pt[f].y=pt[f-no_x].y;
+
+	for(f=0;f<no_x;f++)
+	    {
+	    pt[f].y=sintab[ang]*y_range;
+
+	    if (f==0 || f==no_x-1)
+		pt[f].y+=y_wall;
+	    }
+
+	move-=gap;
+	}
+
+    obj.origin.z=initp.z-move;
+}
+
+
+/* END OF FILE */