/* mesaGIF.c
routines to create GIF files from OpenGL programs.
----------------------------------------------------------------------------
External routines
GIFopen( filename, width, height, NCOLOR, Red, Green, Blue);
         opens a GIF file
GIFsetDelay(int delay);
         sets frame delay for subsequent frames
GIFSwapBuffers();
         outputs current frame
GIFclose();
         closes file
----------------------------------------------------------------------------
cribbed from ppmtogif.c
*/
/* ppmtogif.c - read a portable pixmap and produce a GIF file
**
** Based on GIFENCOD by David Rowley <mgardi@watdscu.waterloo.edu>.A
** Lempel-Zim compression based on "compress".
**
** Modified by Marcel Wijkstra <wijkstra@fwi.uva.nl>
**
**
** Copyright (C) 1989 by Jef Poskanzer.
**
** Permission to use, copy, modify, and distribute this software and its
** documentation for any purpose and without fee is hereby granted, provided
** that the above copyright notice appear in all copies and that both that
** copyright notice and this permission notice appear in supporting
** documentation.  This software is provided "as is" without express or
** implied warranty.
**
** The Graphics Interchange Format(c) is the Copyright property of
** CompuServe Incorporated.  GIF(sm) is a Service Mark property of
** CompuServe Incorporated.
*/

#include <stdio.h>
#include <stdlib.h>
#include <GL/osmesa.h>
#include <string.h>

#ifdef SIGNED_COMPARE_SLOW
typedef unsigned long int count_int;
typedef unsigned short int count_short;
#else /*SIGNED_COMPARE_SLOW*/
typedef long int          count_int;
#endif /*SIGNED_COMPARE_SLOW*/

typedef int             code_int;
/*
 * Pointer to function returning an int
 */
typedef int (* ifunptr) (int, int);


static void compress();
static void Putword();
static void output();
static void cl_block();
static void cl_hash();
static void writeerr();
static void char_init();
static void char_out();
static void flush_char();
static int colorstobpp();

   OSMesaContext ctx;
   void *buffer;
   FILE *f;
         GLubyte *ptr;

   int imageWIDTH,imageHEIGHT;
   int LeftOfs=0;
   int TopOfs=0;
        int Resolution;
        int InitCodeSize;
	int Background=0;
	int Transparent=0;
        int Delay=0;
        int Nframe=0;
     long CountDown;

void GIFsetDelay(int mydelay){
  Delay = mydelay;
}
void GIFsetnframe(long mynframe){
  Nframe = mynframe;
}

void GIFopen(char *Filename,int WIDTH,int HEIGHT, int InputColorMapSize, char *Red, char *Green, char *Blue
){

	int B;
        int ColorMapSize;
	int BitsPerPixel;
	GLsizei glwidth, glheight;

	BitsPerPixel = colorstobpp(InputColorMapSize);
        Resolution = BitsPerPixel;
        ColorMapSize = 1 << BitsPerPixel;

        if( BitsPerPixel <= 1 )
                InitCodeSize = 2;
        else
                InitCodeSize = BitsPerPixel;

   /* Create an 256 Color Index mode context */
	ctx = OSMesaCreateContext( GL_COLOR_INDEX, NULL );
	/* new in 3.5   */
	/*	ctx = OSMesaCreateContextExt( GL_COLOR_INDEX, 0,0,0,NULL ); */
	/* printf("past OSCreate\n");*/
   /* Allocate the image buffer */
   buffer = malloc( 4*WIDTH * HEIGHT );
   /*   printf("calling MakeCurrent\n"); */
   /* Bind the buffer to the context and make it current */
   glwidth=WIDTH;
   glheight=HEIGHT;
   if(!OSMesaMakeCurrent( ctx, buffer, GL_UNSIGNED_BYTE, glwidth, glheight )){
     printf("OSMesaMakeCurrent failed\n");
};
   /*   printf("bound\n"); */
   OSMesaPixelStore(OSMESA_Y_UP,0);
   imageWIDTH = WIDTH;
   imageHEIGHT = HEIGHT;
   if(strcmp(Filename,"-")){
      f = fopen( Filename, "w" );
   }
      else
      {
	f = stdout;
      }
      if (f) {
         int i, x, y;
	 fwrite( "GIF89a", 1, 6, f);
        /*
         * Write out the screen width and height
         */
        Putword( imageWIDTH, f );
        Putword( imageHEIGHT, f );

        /*
         * Indicate that there is a global colour map
         */
        B = 0x80;       /* Yes, there is a color map */

        /*
         * OR in the resolution
         */
        B |= (Resolution - 1) << 5;

        /*
         * OR in the Bits per Pixel
         */
        B |= (BitsPerPixel - 1);

        /*
         * Write it out
         */
        fputc( B, f );

        /*
         * Write out the Background colour
         */
        fputc( Background, f );

        /*
         * Byte of 0's (future expansion)
         */
        fputc( 0, f );

        /*
         * Write out the Global Colour Map
         */


        for( i=0; i<InputColorMapSize; ++i ) {
                fputc( Red[i], f );
                fputc( Green[i], f );
                fputc( Blue[i], f );
        }
	/* fills out color map if size is not power of two */
        for( i=InputColorMapSize; i<ColorMapSize; ++i ) {
                fputc( Red[0], f );
                fputc( Red[0], f );
                fputc( Red[0], f );
        }

	/* Write the Looping Extension */
	if(Nframe != 1){
	fputc(33,f);
	fputc(255,f);
	fputc(11,f);
	 fwrite( "NETSCAPE2.0", 1, 11, f);
	fputc(3,f);
	fputc(1,f);
	/* number of interations */
	Putword(20,f);
	fputc(0,f);
	}

      }
}
void GIFSwapBuffers(){
         int i, x, y;
         ptr = buffer;
        CountDown = (long)imageWIDTH * (long)imageHEIGHT;

  if(f){

	/*
	 * Write out extension for transparent colour index
	 and specify delay
	 */
	    fputc( '!', f );
	    fputc( 0xf9, f );
	    fputc( 4, f );
	    fputc( 4, f ); /* Restore to background not transparent*/
	    Putword( Delay, f ); /* delay in 1/100 second */
	    fputc( Transparent, f );
	    fputc( 0, f);  /* end of block */

        /*
         * Write an Image separator
         */
        fputc( ',', f );

        /*
         * Write the Image header
         */

        Putword( LeftOfs, f );
        Putword( TopOfs, f );
        Putword( imageWIDTH, f );
        Putword( imageHEIGHT, f );

        /*
         * Write out  that the image is not interlaced
         */
                fputc( 0x00, f );

        /*
         * Write out the initial code size
         */
        fputc( InitCodeSize, f );

        /*
         * Go and actually compress the data
         */
        compress( InitCodeSize+1, f );

        /*
         * Write out a Zero-length packet (to end the series)
         */
        fputc( 0, f );

  }
}
void GIFclose(){

      /* write GIF file */
	 if(f){

	   /*
         * Write the GIF file terminator
         */
        fputc( ';', f );
         fclose(f);
      }

   /* free the image buffer */
   free( buffer );

   /* destroy the context */
   OSMesaDestroyContext( ctx );
}

static int
GIFNextPixel( )
{
        int r;

        if( CountDown == 0 )
                return EOF;

        --CountDown;

	r = *ptr;
	++ptr;

        return r;
}


/* code to Mesa Code copied unchanged from ppmtogif.c */
/***************************************************************************
 *
 *  GIFCOMPR.C       - GIF Image compression routines
 *
 *  Lempel-Ziv compression based on 'compress'.  GIF modifications by
 *  David Rowley (mgardi@watdcsu.waterloo.edu)
 *
 ***************************************************************************/

/*
 * General DEFINEs
 */

#define BITS    12

#define HSIZE  5003            /* 80% occupancy */

#ifdef NO_UCHAR
 typedef char   char_type;
#else /*NO_UCHAR*/
 typedef        unsigned char   char_type;
#endif /*NO_UCHAR*/

/*
 *
 * GIF Image compression - modified 'compress'
 *
 * Based on: compress.c - File compression ala IEEE Computer, June 1984.
 *
 * By Authors:  Spencer W. Thomas       (decvax!harpo!utah-cs!utah-gr!thomas)
 *              Jim McKie               (decvax!mcvax!jim)
 *              Steve Davies            (decvax!vax135!petsd!peora!srd)
 *              Ken Turkowski           (decvax!decwrl!turtlevax!ken)
 *              James A. Woods          (decvax!ihnp4!ames!jaw)
 *              Joe Orost               (decvax!vax135!petsd!joe)
 *
 */
#include <ctype.h>

#define ARGVAL() (*++(*argv) || (--argc && *++argv))

static int n_bits;                        /* number of bits/code */
static int maxbits = BITS;                /* user settable max # bits/code */
static code_int maxcode;                  /* maximum code, given n_bits */
static code_int maxmaxcode = (code_int)1 << BITS; /* should NEVER generate this code */
#ifdef COMPATIBLE               /* But wrong! */
# define MAXCODE(n_bits)        ((code_int) 1 << (n_bits) - 1)
#else /*COMPATIBLE*/
# define MAXCODE(n_bits)        (((code_int) 1 << (n_bits)) - 1)
#endif /*COMPATIBLE*/

static count_int htab [HSIZE];
static unsigned short codetab [HSIZE];
#define HashTabOf(i)       htab[i]
#define CodeTabOf(i)    codetab[i]

static code_int hsize = HSIZE;                 /* for dynamic table sizing */

/*
 * To save much memory, we overlay the table used by compress() with those
 * used by decompress().  The tab_prefix table is the same size and type
 * as the codetab.  The tab_suffix table needs 2**BITS characters.  We
 * get this from the beginning of htab.  The output stack uses the rest
 * of htab, and contains characters.  There is plenty of room for any
 * possible stack (stack used to be 8000 characters).
 */

#define tab_prefixof(i) CodeTabOf(i)
#define tab_suffixof(i)        ((char_type*)(htab))[i]
#define de_stack               ((char_type*)&tab_suffixof((code_int)1<<BITS))

static code_int free_ent = 0;                  /* first unused entry */

/*
 * block compression parameters -- after all codes are used up,
 * and compression rate changes, start over.
 */
static int clear_flg = 0;

static int offset;
static long int in_count = 1;            /* length of input */
static long int out_count = 0;           /* # of codes output (for debugging) */

/*
 * compress stdin to stdout
 *
 * Algorithm:  use open addressing double hashing (no chaining) on the
 * prefix code / next character combination.  We do a variant of Knuth's
 * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
 * secondary probe.  Here, the modular division first probe is gives way
 * to a faster exclusive-or manipulation.  Also do block compression with
 * an adaptive reset, whereby the code table is cleared when the compression
 * ratio decreases, but after the table fills.  The variable-length output
 * codes are re-sized at this point, and a special CLEAR code is generated
 * for the decompressor.  Late addition:  construct the table according to
 * file size for noticeable speed improvement on small files.  Please direct
 * questions about this implementation to ames!jaw.
 */

static int g_init_bits;
static FILE* g_outfile;

static int ClearCode;
static int EOFCode;

void compress( init_bits, outfile)
int init_bits;
FILE* outfile;

{
    register long fcode;
    register code_int i /* = 0 */;
    register int c;
    register code_int ent;
    register code_int disp;
    register code_int hsize_reg;
    register int hshift;

    /*
     * Set up the globals:  g_init_bits - initial number of bits
     *                      g_outfile   - pointer to output file
     */
    g_init_bits = init_bits;
    g_outfile = outfile;

    /*
     * Set up the necessary values
     */
    offset = 0;
    out_count = 0;
    clear_flg = 0;
    in_count = 1;
    maxcode = MAXCODE(n_bits = g_init_bits);

    ClearCode = (1 << (init_bits - 1));
    EOFCode = ClearCode + 1;
    free_ent = ClearCode + 2;

    char_init();

    ent = GIFNextPixel( );

    hshift = 0;
    for ( fcode = (long) hsize;  fcode < 65536L; fcode *= 2L )
        ++hshift;
    hshift = 8 - hshift;                /* set hash code range bound */

    hsize_reg = hsize;
    cl_hash( (count_int) hsize_reg);            /* clear hash table */

    output( (code_int)ClearCode );

#ifdef SIGNED_COMPARE_SLOW
    while ( (c = GIFNextPixel()) != (unsigned) EOF ) {
#else /*SIGNED_COMPARE_SLOW*/
    while ( (c = GIFNextPixel(  )) != EOF ) {  /* } */
#endif /*SIGNED_COMPARE_SLOW*/

        ++in_count;

        fcode = (long) (((long) c << maxbits) + ent);
        i = (((code_int)c << hshift) ^ ent);    /* xor hashing */

        if ( HashTabOf (i) == fcode ) {
            ent = CodeTabOf (i);
            continue;
        } else if ( (long)HashTabOf (i) < 0 )      /* empty slot */
            goto nomatch;
        disp = hsize_reg - i;           /* secondary hash (after G. Knott) */
        if ( i == 0 )
            disp = 1;
probe:
        if ( (i -= disp) < 0 )
            i += hsize_reg;

        if ( HashTabOf (i) == fcode ) {
            ent = CodeTabOf (i);
            continue;
        }
        if ( (long)HashTabOf (i) > 0 )
            goto probe;
nomatch:
        output ( (code_int) ent );
        ++out_count;
        ent = c;
#ifdef SIGNED_COMPARE_SLOW
        if ( (unsigned) free_ent < (unsigned) maxmaxcode) {
#else /*SIGNED_COMPARE_SLOW*/
        if ( free_ent < maxmaxcode ) {  /* } */
#endif /*SIGNED_COMPARE_SLOW*/
            CodeTabOf (i) = free_ent++; /* code -> hashtable */
            HashTabOf (i) = fcode;
        } else
                cl_block();
    }
    /*
     * Put out the final code.
     */
    output( (code_int)ent );
    ++out_count;
    output( (code_int) EOFCode );
}

/*****************************************************************
 * TAG( output )
 *
 * Output the given code.
 * Inputs:
 *      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
 *              that n_bits =< (long)wordsize - 1.
 * Outputs:
 *      Outputs code to the file.
 * Assumptions:
 *      Chars are 8 bits long.
 * Algorithm:
 *      Maintain a BITS character long buffer (so that 8 codes will
 * fit in it exactly).  Use the VAX insv instruction to insert each
 * code in turn.  When the buffer fills up empty it and start over.
 */

static unsigned long cur_accum = 0;
static int cur_bits = 0;

static unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
                                  0x001F, 0x003F, 0x007F, 0x00FF,
                                  0x01FF, 0x03FF, 0x07FF, 0x0FFF,
                                  0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };

static void output( code )
code_int  code;
{
    cur_accum &= masks[ cur_bits ];

    if( cur_bits > 0 )
        cur_accum |= ((long)code << cur_bits);
    else
        cur_accum = code;

    cur_bits += n_bits;

    while( cur_bits >= 8 ) {
        char_out( (unsigned int)(cur_accum & 0xff) );
        cur_accum >>= 8;
        cur_bits -= 8;
    }

    /*
     * If the next entry is going to be too big for the code size,
     * then increase it, if possible.
     */
   if ( free_ent > maxcode || clear_flg ) {

            if( clear_flg ) {

                maxcode = MAXCODE (n_bits = g_init_bits);
                clear_flg = 0;

            } else {

                ++n_bits;
                if ( n_bits == maxbits )
                    maxcode = maxmaxcode;
                else
                    maxcode = MAXCODE(n_bits);
            }
        }

    if( code == EOFCode ) {
        /*
         * At EOF, write the rest of the buffer.
         */
        while( cur_bits > 0 ) {
                char_out( (unsigned int)(cur_accum & 0xff) );
                cur_accum >>= 8;
                cur_bits -= 8;
        }

	cur_accum = 0;
	cur_bits = 0;


        flush_char();

        fflush( g_outfile );

        if( ferror( g_outfile ) )
                writeerr();
    }
}

/*
 * Clear out the hash table
 */
static void
cl_block ()             /* table clear for block compress */
{

        cl_hash ( (count_int) hsize );
        free_ent = ClearCode + 2;
        clear_flg = 1;

        output( (code_int)ClearCode );
}

static void
cl_hash(hsize)          /* reset code table */
register count_int hsize;
{

        register count_int *htab_p = htab+hsize;

        register long i;
        register long m1 = -1;

        i = hsize - 16;
        do {                            /* might use Sys V memset(3) here */
                *(htab_p-16) = m1;
                *(htab_p-15) = m1;
                *(htab_p-14) = m1;
                *(htab_p-13) = m1;
                *(htab_p-12) = m1;
                *(htab_p-11) = m1;
                *(htab_p-10) = m1;
                *(htab_p-9) = m1;
                *(htab_p-8) = m1;
                *(htab_p-7) = m1;
                *(htab_p-6) = m1;
                *(htab_p-5) = m1;
                *(htab_p-4) = m1;
                *(htab_p-3) = m1;
                *(htab_p-2) = m1;
                *(htab_p-1) = m1;
                htab_p -= 16;
        } while ((i -= 16) >= 0);

        for ( i += 16; i > 0; --i )
                *--htab_p = m1;
}

static void
writeerr()
{
}

/******************************************************************************
 *
 * GIF Specific routines
 *
 ******************************************************************************/

/*
 * Number of characters so far in this 'packet'
 */
static int a_count;

/*
 * Set up the 'byte output' routine
 */
static void
char_init()
{
        a_count = 0;
}

/*
 * Define the storage for the packet accumulator
 */
static char accum[ 256 ];

/*
 * Add a character to the end of the current packet, and if it is 254
 * characters, flush the packet to disk.
 */
static void
char_out( c )
int c;
{
        accum[ a_count++ ] = c;
        if( a_count >= 254 )
                flush_char();
}

/*
 * Flush the packet to disk, and reset the accumulator
 */
static void
flush_char()
{
        if( a_count > 0 ) {
                fputc( a_count, g_outfile );
                fwrite( accum, 1, a_count, g_outfile );
                a_count = 0;
        }
}

static void Putword( w, fp )
int w;
FILE* fp;
{
        fputc( w & 0xff, fp );
        fputc( (w / 256) & 0xff, fp );
}

static int colorstobpp( colors )
int colors;
    {
    int bpp;

    if ( colors <= 2 )
        bpp = 1;
    else if ( colors <= 4 )
        bpp = 2;
    else if ( colors <= 8 )
        bpp = 3;
    else if ( colors <= 16 )
        bpp = 4;
    else if ( colors <= 32 )
        bpp = 5;
    else if ( colors <= 64 )
        bpp = 6;
    else if ( colors <= 128 )
        bpp = 7;
    else if ( colors <= 256 )
        bpp = 8;
    else
      bpp = 8;
    return bpp;
    }


/* bounce.c */


/*
 * Bouncing ball demo.
 *
 * Brian Paul
 */



#include <math.h>
#include <stdio.h>
#include <GL/osmesa.h>


#define COS(X)   cos( (X) * 3.14159/180.0 )
#define SIN(X)   sin( (X) * 3.14159/180.0 )


GLuint Ball;
GLenum Mode;
GLfloat Zrot = 0.0, Zstep = 4.0;
GLfloat Xpos = 0.0, Ypos = 1.0;
GLfloat Xvel = 0.1, Yvel = 0.0;
GLfloat Xmin=-4.0, Xmax=4.0;
GLfloat Ymin=-3.8, Ymax=4.0;
GLfloat G = -0.05;



static GLuint make_ball( void )
{
   GLuint list;
   GLfloat a, b;
   GLfloat da = 18.0, db = 18.0;
   GLfloat radius = 1.0;
   GLuint color;
   GLfloat x, y, z;

   list = glGenLists( 1 );

   glNewList( list, GL_COMPILE );

   color = 0;
   for (a=-90.0;a+da<=90.0;a+=da) {

      glBegin( GL_QUAD_STRIP );
      for (b=0.0;b<=360.0;b+=db) {

	 if (color) {
	    glIndexi(2);
	 }
	 else {
	    glIndexi(1);
	 }

	 x = COS(b) * COS(a);
	 y = SIN(b) * COS(a);
	 z = SIN(a);
	 glVertex3f( x, y, z );

	 x = radius * COS(b) * COS(a+da);
	 y = radius * SIN(b) * COS(a+da);
	 z = radius * SIN(a+da);
	 glVertex3f( x, y, z );

	 color = 1-color;
      }
      glEnd();

   }

   glEndList();

   return list;
}



static void reshape( int width, int height )
{
   glViewport(0, 0, (GLint)width, (GLint)height);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho( -6.0, 6.0, -6.0, 6.0, -6.0, 6.0 );
   glMatrixMode(GL_MODELVIEW);
}



static void draw( void )
{
   GLint i;

   glClear( GL_COLOR_BUFFER_BIT );

   glIndexi(3);
   glBegin( GL_LINES );
   for (i=-5;i<=5;i++) {
      glVertex2i( i, -5 );   glVertex2i( i, 5 );
   }
   for (i=-5;i<=5;i++) {
      glVertex2i( -5,i );   glVertex2i( 5,i );
   }
   for (i=-5;i<=5;i++) {
      glVertex2i( i, -5 );  glVertex2f( i*1.15, -5.9 );
   }
   glVertex2f( -5.3, -5.35 );    glVertex2f( 5.3, -5.35 );
   glVertex2f( -5.75, -5.9 );     glVertex2f( 5.75, -5.9 );
   glEnd();


   glPushMatrix();
   glTranslatef( Xpos, Ypos, 0.0 );
   glScalef( 2.0, 2.0, 2.0 );
   glRotatef( 8.0, 0.0, 0.0, 1.0 );
   glRotatef( 90.0, 1.0, 0.0, 0.0 );
   glRotatef( Zrot, 0.0, 0.0, 1.0 );


   glCallList( Ball );

   glPopMatrix();

   glFlush();
   GIFSwapBuffers();
}


static void idle( void )
{
   static float vel0 = -100.0;

   Zrot += Zstep;

   Xpos += Xvel;
   if (Xpos>=Xmax) {
      Xpos = Xmax;
      Xvel = -Xvel;
      Zstep = -Zstep;
   }
   if (Xpos<=Xmin) {
      Xpos = Xmin;
      Xvel = -Xvel;
      Zstep = -Zstep;
   }

   Ypos += Yvel;
   Yvel += G;
   if (Ypos<Ymin) {
      Ypos = Ymin;
      if (vel0==-100.0)  vel0 = fabs(Yvel);
      Yvel = vel0;
   }
   draw();
}



int main( int argc, char *argv[] )
{
   int i;
   int limit=100;

  char Red[4], Green[4], Blue[4];

   Red[0] = 0;
   Green[0] = 0;
   Blue[0] = 0;
   Red[1] = 255;
   Green[1] = 255;
   Blue[1] = 255;
   Red[2] = 255;
   Green[2] = 0;
   Blue[2] = 0;
   Red[3] = 0;
   Green[3] = 255;
   Blue[3] = 0;

   GIFopen("newbounce.gif",400,400,2,Red,Green,Blue);
   Ball = make_ball();
   glCullFace( GL_BACK );
   glEnable( GL_CULL_FACE );
   glDisable( GL_DITHER );
   glShadeModel( GL_FLAT );


   reshape(400,400);
   GIFsetDelay(100);
   draw();
   GIFsetDelay(0);
   for (i=1;i<limit;i++){
   idle();
   }
   GIFsetDelay(1000);
   idle();
   GIFclose();
   return 0;
}
/* 
3.5 compile: "pgcc -o example example.c -I/usr/local/include -L/usr/local/lib -lglut -lOSMesa -lGLU -lGL
pre 3.5 compile: "pgcc -o example example.c  -I/usr/local/include -L/usr/local/lib -lglut -lGLU -lGL
*/
