---

/home/rdbrown/doxygen/cse125g1/src/modules/arrows/arrowstest/ArrowsTest.cpp

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>

#ifdef WIN32
#include <windows.h>
const float M_PI = { 3.14159265f };
#endif

#include "axes/axes.h"
#include "arrows/arrows.h"
#include "input/input.h"
#include "playerControl/playerControl.h"
#include "fog/fog.h"
#include "windowControl/windowControl.h"
#include "timer/timer.h"
#include "stringDraw/stringDraw.h"
#include "lighting/lighting.h"
#include "opengl.h"


/* Constants and Defines */
const char *WINDOWTITLE = { "Robin Hood and His Merry Men" };
#define ESCAPE          0x1b
const int INIT_WINDOW_SIZE = { 600 };
const float SCLFACT = { 0.005f };
const float MINSCALE = { 0.05f };
/* active mouse buttons (or them together):                             */

const int LEFT   = { 4 };
const int MIDDLE = { 2 };
const int RIGHT  = { 1 };



/* window background color (rgba):                                      */
const float BACKCOLOR[] = { 0.2, 0.2, 1., 0. };



int     ActiveButton;           /* current button that is down          */
int     Debug;                  /* ON means print debug info            */
int     LeftButton;             /* either ROTATE or SCALE               */
int     MainWindow;             /* window id for main graphics window   */
float   Scale;          /* scaling factors                      */

int PointsOn;
int LightOn;
int AeroOn;
int FontType;




ArrowSystem arrows;
Axes axes;
PlayerControl player;
WindowControl windowControl;
Fog fog;
Timer timer;
Lighting lighting;

//float eyeTargetX = 0.0;
//float eyeTargetY = 0.0;
int fpsCounter = 0;
char fpsMessage[50];


void    Display( void );
void    DoRasterString( float, float, float, char * );
void    DoStrokeString( float, float, float, float, char * );
void    InitGraphics( void );
//void  Keyboard( unsigned char, int, int );

void    Reset( void );
void    Resize( int, int );
void    Visibility( int );
//void  KeyboardSpecial( int c, int x, int y );



int
main( int argc, char *argv[] )
{
//INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
//{
        glutInit( &argc, argv );

        InitGraphics();
        srand(12);

        /* create the display structures that will not change:          */
        Reset();

        glutMainLoop();

        /* this is here to make the compiler happy:                     */
        return 0;
}


void
MouseMotion(int x, int y)
{
        player.MouseMotion(x,y);
}



void
Display( void )
{

        /* set which window we want to do the graphics into:            */
        // probably could be moved to init or somewhere else
        glutSetWindow( MainWindow );


        /* erase the background:                                        */
        //glDrawBuffer( GL_BACK );
        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
        glEnable( GL_DEPTH_TEST );


        /* set the viewing volume:                                      */
        /* remember that the eye is at the origin looking in -Z         */
        /* remember that the Z values are actually                      */
        /* given as DISTANCES IN FRONT OF THE EYE                       */

        // XXX: move to init
        glMatrixMode( GL_PROJECTION );
        glLoadIdentity();
        gluPerspective( 90., 1.,        0.1, 1000. );

        //Do Camera Stuff
        glMatrixMode( GL_MODELVIEW );
        glLoadIdentity();
        float Yrot, Xrot, PosX, PosY, PosZ;
        Yrot = player.GetYrot();
        Xrot = player.GetXrot();
        PosX = player.GetPosX();
        PosY = player.GetPosY();
        PosZ = player.GetPosZ();
        gluLookAt( PosX+2*sin((-Yrot-5)*(M_PI/180.0)), PosY+1.0, PosZ+2*cos((-Yrot-5)*(M_PI/180.0) ),     PosX, PosY+1.0-Xrot/15.0, PosZ,     0., 1., 0. );



        /* place the objects into the viewing volume:                   */
        fog.Enable();
        axes.Draw();

        // XXX: move to init
        glPointSize(2);
        glLineWidth(2);

        lighting.Enable();

        // XXX: Optimization-> place outside display loop
        glEnable(GL_NORMALIZE);
        glShadeModel(GL_SMOOTH);


        //Draw guy
        glPushMatrix();
                glTranslatef(PosX, PosY, PosZ);
                glRotatef( -Yrot, 0., 1., 0. );
                glColor3f( 1.0, 1.0, 1.0);
                glutSolidCube(1.0);
        glPopMatrix();

        //Draw Crummy Tree
        glPushMatrix();
                glTranslatef(20.0f, 30.0, 20.0f);
                glScalef(1.0, 30.0, 1.0);
                glColor3f(0.56f,0.27f,.07f);
                glutSolidCube(4.0);
        glPopMatrix();

        //Draw crummy target
        glPushMatrix();
                glTranslatef(0.0f, 0.0, 21.0f);
                glColor3f(0.56f,0.27f,1.0f);
                glutSolidSphere(4.0,15,15);
        glPopMatrix();

        if (1.0/(timer.GetTimeChange()) < 30)
        {
                timer.Update();
                return;
        }

        if(true)
        {
                glNormal3f( 0.0, 1.0, 0.0);
                glColor3f( 0.0, 1.0, 0.0);
                glBegin(GL_QUADS);
                        glVertex3f(-200.0f, -10.1f, -200.0f);
                        glVertex3f(-200.0f, -10.1f, 200.0f);
                        glVertex3f(200.0f, -10.1f, 200.0f);
                        glVertex3f(200.0f, -10.1f, -200.0f);
                glEnd();
        }


        // makes arrows + axis immune to lighting
        lighting.Disable();

        arrows.Update(timer.GetTimeChange());
        arrows.Draw();
        arrows.stickySphere(Vector3(0.0,0.0,21.0),4);
        arrows.stickyCylinder(Vector3(20.0f,0.0f,20.0f), 2.0f, 60.1f, -10.1f);

        fog.Disable();
        player.DrawTarget();

        fpsCounter++;
        if (fpsCounter >= 9) {
                fpsCounter = 0;
                sprintf(fpsMessage, "fps: %f", 1.0/(timer.GetTimeChange()) );
        }

        timer.Update();

        draw2dString(5.0f, 5.0f, fpsMessage);

        /* swap the double-buffered framebuffers:                       */
        glutSwapBuffers();

        /* be sure the graphics buffer has been sent:                   */
        glFlush();
}

void
Animate( void )
{
        /* force a call to Display() next time it is convenient:        */
        player.HandleInput(timer.GetTimeChange());
        windowControl.Update();
        glutSetWindow( MainWindow );
        glutPostRedisplay();
}


void
ToggleArrowStorm(void)
{
        static bool doShower = false;
        doShower = !doShower;
        arrows.DoArrowShower(doShower);

}


void
InitGraphics( void )
{
        if( Debug )
          //fprintf( stderr, "InitGraphics\n" );


        /* setup the display mode:                                      */
        /* ( *must* be done before call to glutCreateWindow() )         */
        /* ask for color, double-buffering, and z-buffering:            */

        glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );


        /* set the initial window configuration:                        */
        glutInitWindowSize( INIT_WINDOW_SIZE, INIT_WINDOW_SIZE );


        /* open the window and set its title:                           */
        MainWindow = glutCreateWindow( WINDOWTITLE );
        glutSetWindowTitle( WINDOWTITLE );


        /* setup the clear values:                                      */
        glClearColor( BACKCOLOR[0], BACKCOLOR[1], BACKCOLOR[2], BACKCOLOR[3] );

        //Good place to initialize stuff
        arrows.Init(700, 1.0f, -10.0);
        axes.Init(5.0f);
        fog.Init();
        windowControl.Init();
        player.Init(0.0f,0.0f,30.0f,&arrows);
        InputSetMouseMotion(MouseMotion);
        lighting.Init();
        timer.Init();

        InputSetKeyDown('t', ToggleArrowStorm);

        /* setup the callback routines:                                 */
        /* DisplayFunc -- redraw the window                             */
        /* ReshapeFunc -- handle the user resizing the window           */
        /* KeyboardFunc -- handle a keyboard input                      */
        /* MouseFunc -- handle the mouse button going down or up        */
        /* MotionFunc -- handle the mouse moving with a button down     */
        /* PassiveMotionFunc -- handle the mouse moving with a button up*/
        /* VisibilityFunc -- handle a change in window visibility       */
        /* EntryFunc    -- handle the cursor entering or leaving the window */
        /* SpecialFunc -- handle special keys on the keyboard           */
        /* SpaceballMotionFunc -- handle spaceball translation          */
        /* SpaceballRotateFunc -- handle spaceball rotation             */
        /* SpaceballButtonFunc -- handle spaceball button hits          */
        /* ButtonBoxFunc -- handle button box hits                      */
        /* DialsFunc -- handle dial rotations                           */
        /* TabletMotionFunc -- handle digitizing tablet motion          */
        /* TabletButtonFunc -- handle digitizing tablet button hits     */
        /* MenuStateFunc -- declare when a pop-up menu is in use        */
        /* IdleFunc -- what to do when nothing else is going on         */
        /* TimerFunc -- trigger something to happen every so often      */


        //void InputSystemKeyDown(char key, int xMouse, int yMouse);
        //void InputSystemKeyUp(char key, int xMouse, int yMouse);
        //void InputSystemMouseMotion(int x, int y);
        //void InputSystemMouseButton(int button, int state, int x, int y);


        glutKeyboardFunc( InputSystemKeyDown );
        glutKeyboardUpFunc ( InputSystemKeyUp );
        glutMouseFunc( InputSystemMouseButton );
        glutPassiveMotionFunc( InputSystemMouseMotion );
        glutMotionFunc( InputSystemMouseMotion );

        glutSetWindow( MainWindow );
        glutDisplayFunc( Display );
        glutReshapeFunc( Resize );

        glutVisibilityFunc( Visibility );
        glutEntryFunc( NULL );

        glutSpaceballMotionFunc( NULL );
        glutSpaceballRotateFunc( NULL );
        glutSpaceballButtonFunc( NULL );
        glutButtonBoxFunc( NULL );
        glutDialsFunc( NULL );
        glutTabletMotionFunc( NULL );
        glutTabletButtonFunc( NULL );
        glutMenuStateFunc( NULL );
        glutIdleFunc( Animate );

        glutTimerFunc( 0, NULL, 0 );
}



void
Reset( void )
{
        //AxesOn = true;
        Debug = false;
        LightOn = true;
        printf("Reset called\n");
        glutSetWindow( MainWindow );
        glutPostRedisplay();
}



void
Resize( int width, int height )
{
        if( Debug )
                fprintf( stderr, "ReSize: %d, %d\n", width, height );

        /* don't really need to do anything since window size is        */
        /* checked each time in Display():                              */

        float vx, vy, v;
        /* handle resizing              */
        // XXX: could move to resize function
        vx = glutGet( GLUT_WINDOW_WIDTH );
        vy = glutGet( GLUT_WINDOW_HEIGHT );
        v = vx < vy ? vx : vy;                  /* minimum dimension    */
        //xl = ( vx - v ) / 2;
        //yb = ( vy - v ) / 2;
        glViewport( 0,0,vx,vy);//xl, yb,  v, v );
        //Xmouse = 0.0;//vx / 2.0;
        //Ymouse = 0.0;//vy / 2.0;

        //Xrot = ( ANGFACT*(150) );
        //Yrot = ( ANGFACT*(150) );

        //printf("resize xmouse, ymouse %d, %d\n", Xmouse, Ymouse);
        glutSetWindow( MainWindow );
        glutPostRedisplay();
}




void
Visibility(int state)           /* GLUT_VISIBLE or GLUT_NOT_VISIBLE     */
{
        if( Debug )
                fprintf( stderr, "Visibility: %d\n", state );

        if( state == GLUT_VISIBLE )
        {
                glutSetWindow( MainWindow );
                glutPostRedisplay();
        }
        else
        {
                /* could optimize by keeping track of the fact          */
                /* that the window is not visible and avoid             */
                /* animating or redrawing it ...                        */
        }
}

---