/* Copyright (c) Mark J. Kilgard, 1994. */

/**

* (c) Copyright 1993, 1994, Silicon Graphics, Inc.

* ALL RIGHTS RESERVED

* Permission to use, copy, modify, and distribute this software for

* any purpose and without fee is hereby granted, provided that the above

* copyright notice appear in all copies and that both the copyright notice

* and this permission notice appear in supporting documentation, and that

* the name of Silicon Graphics, Inc. not be used in advertising

* or publicity pertaining to distribution of the software without specific,

* written prior permission.

*

* THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"

* AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,

* INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR

* FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON

* GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,

* SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY

* KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,

* LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF

* THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN

* ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON

* ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE

* POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.

*

* US Government Users Restricted Rights

* Use, duplication, or disclosure by the Government is subject to

* restrictions set forth in FAR 52.227.19(c)(2) or subparagraph

* (c)(1)(ii) of the Rights in Technical Data and Computer Software

* clause at DFARS 252.227-7013 and/or in similar or successor

* clauses in the FAR or the DOD or NASA FAR Supplement.

* Unpublished-- rights reserved under the copyright laws of the

* United States. Contractor/manufacturer is Silicon Graphics,

* Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311.

*

* OpenGL(TM) is a trademark of Silicon Graphics, Inc.

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <sys/time.h>

#include <GLUT/glut.h>

#include "atlantis.h"

fishRec sharks[NUM_SHARKS];

fishRec momWhale;

fishRec babyWhale;

fishRec dolph;

GLboolean Timing = GL_TRUE;

int w_win = 640;

int h_win = 480;

GLint count = 0;

GLenum StrMode = GL_VENDOR;

GLboolean moving;

static double mtime(void)

{

struct timeval tk_time;

struct timezone tz;

return 4294.967296 * tk_time.tv_sec + 0.000001 * tk_time.tv_usec;

}

static double filter(double in, double *save)

{

static double k1 = 0.9;

static double k2 = 0.05;

save[3] = in;

save[1] = save[0]*k1 + k2*(save[3] + save[2]);

save[0]=save[1];

save[2]=save[3];

}

void DrawStr(const char *str)

{

GLint i = 0;

if(!str) return;

while(str[i])

{

glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, str[i]);

i++;

}

}

void

InitFishs(void)

{

int i;

for (i = 0; i < NUM_SHARKS; i++) {

sharks[i].x = 70000.0 + rand() % 6000;

sharks[i].y = rand() % 6000;

sharks[i].z = rand() % 6000;

sharks[i].psi = rand() % 360 - 180.0;

sharks[i].v = 1.0;

}

dolph.x = 30000.0;

dolph.y = 0.0;

dolph.z = 6000.0;

dolph.psi = 90.0;

dolph.theta = 0.0;

dolph.v = 3.0;

momWhale.x = 70000.0;

momWhale.y = 0.0;

momWhale.z = 0.0;

momWhale.psi = 90.0;

momWhale.theta = 0.0;

momWhale.v = 3.0;

babyWhale.x = 60000.0;

babyWhale.y = -2000.0;

babyWhale.z = -2000.0;

babyWhale.psi = 90.0;

babyWhale.theta = 0.0;

babyWhale.v = 3.0;

}

void

Atlantis_Init(void)

{

static float ambient[] = {0.2, 0.2, 0.2, 1.0};

static float diffuse[] = {1.0, 1.0, 1.0, 1.0};

static float position[] = {0.0, 1.0, 0.0, 0.0};

static float mat_shininess[] = {90.0};

static float mat_specular[] = {0.8, 0.8, 0.8, 1.0};

static float mat_diffuse[] = {0.46, 0.66, 0.795, 1.0};

static float mat_ambient[] = {0.3, 0.4, 0.5, 1.0};

static float lmodel_ambient[] = {0.4, 0.4, 0.4, 1.0};

static float lmodel_localviewer[] = {0.0};

//GLfloat map1[4] = {0.0, 0.0, 0.0, 0.0};

//GLfloat map2[4] = {0.0, 0.0, 0.0, 0.0};

static float fog_color[] = {0.0, 0.5, 0.9, 1.0};

glFrontFace(GL_CCW);

glDepthFunc(GL_LESS);

glEnable(GL_DEPTH_TEST);

glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);

glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);

glLightfv(GL_LIGHT0, GL_POSITION, position);

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);

glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, lmodel_localviewer);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);

glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);

glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);

glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);

InitFishs();

glEnable(GL_FOG);

glFogi(GL_FOG_MODE, GL_EXP);

glFogf(GL_FOG_DENSITY, 0.0000025);

glFogfv(GL_FOG_COLOR, fog_color);

glClearColor(0.0, 0.5, 0.9, 1.0);

}

void

Atlantis_Reshape(int width, int height)

{

w_win = width;

h_win = height;

glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(60.0, (GLfloat) width / (GLfloat) height, 20000.0, 300000.0);

glMatrixMode(GL_MODELVIEW);

}

void

Atlantis_Animate(void)

{

int i;

for (i = 0; i < NUM_SHARKS; i++) {

SharkPilot(&sharks[i]);

SharkMiss(i);

}

WhalePilot(&dolph);

dolph.phi++;

//glutPostRedisplay();

WhalePilot(&momWhale);

momWhale.phi++;

WhalePilot(&babyWhale);

babyWhale.phi++;

}

void

Atlantis_Key(unsigned char key, int x, int y)

{

switch (key) {

case 't':

break;

case ' ':

switch(StrMode)

{

case GL_EXTENSIONS:

StrMode = GL_VENDOR;

break;

case GL_VENDOR:

StrMode = GL_RENDERER;

break;

case GL_RENDERER:

StrMode = GL_VERSION;

break;

case GL_VERSION:

StrMode = GL_EXTENSIONS;

break;

}

break;

case 27: /* Esc will quit */

exit(1);

break;

moving = GL_TRUE;

//glutIdleFunc(Animate);

break;

moving = GL_FALSE;

//glutIdleFunc(NULL);

break;

if (!moving) {

Atlantis_Animate();

}

}

}

/*

void Display(void)

{

static float P123[3] = {-448.94, -203.14, 9499.60};

static float P124[3] = {-442.64, -185.20, 9528.07};

static float P125[3] = {-441.07, -148.05, 9528.07};

static float P126[3] = {-443.43, -128.84, 9499.60};

static float P127[3] = {-456.87, -146.78, 9466.67};

static float P128[3] = {-453.68, -183.93, 9466.67};

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glPushMatrix();

FishTransform(&dolph);

DrawDolphin(&dolph);

glPopMatrix();

glutSwapBuffers();

}

*/

void

Atlantis_Display(void)

{

int i;

static double th[4] = {0.0, 0.0, 0.0, 0.0};

static double t1 = 0.0, t2 = 0.0, t;

char num_str[128];

t1 = t2;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

for (i = 0; i < NUM_SHARKS; i++) {

glPushMatrix();

FishTransform(&sharks[i]);

DrawShark(&sharks[i]);

glPopMatrix();

}

glPushMatrix();

FishTransform(&dolph);

DrawDolphin(&dolph);

glPopMatrix();

glPushMatrix();

FishTransform(&momWhale);

DrawWhale(&momWhale);

glPopMatrix();

glPushMatrix();

FishTransform(&babyWhale);

glScalef(0.45, 0.45, 0.3);

DrawWhale(&babyWhale);

glPopMatrix();

if(Timing)

{

t2 = mtime();

t = t2 - t1;

if(t > 0.0001) t = 1.0 / t;

glDisable(GL_LIGHTING);

//glDisable(GL_DEPTH_TEST);

glColor3f(1.0, 0.0, 0.0);

glMatrixMode (GL_PROJECTION);

glPushMatrix();

glLoadIdentity();

glOrtho(0, w_win, 0, h_win, -10.0, 10.0);

glRasterPos2f(5.0, 5.0);

switch(StrMode)

{

case GL_VENDOR:

sprintf(num_str, "%0.2f Hz, %dx%d, VENDOR: ", filter(t, th), w_win, h_win);

DrawStr(num_str);

DrawStr(glGetString(GL_VENDOR));

break;

case GL_RENDERER:

sprintf(num_str, "%0.2f Hz, %dx%d, RENDERER: ", filter(t, th), w_win, h_win);

DrawStr(num_str);

DrawStr(glGetString(GL_RENDERER));

break;

case GL_VERSION:

sprintf(num_str, "%0.2f Hz, %dx%d, VERSION: ", filter(t, th), w_win, h_win);

DrawStr(num_str);

DrawStr(glGetString(GL_VERSION));

break;

case GL_EXTENSIONS:

sprintf(num_str, "%0.2f Hz, %dx%d, EXTENSIONS: ", filter(t, th), w_win, h_win);

DrawStr(num_str);

DrawStr(glGetString(GL_EXTENSIONS));

break;

}

glPopMatrix();

glMatrixMode(GL_MODELVIEW);

glEnable(GL_LIGHTING);

//glEnable(GL_DEPTH_TEST);

}

count++;

glutSwapBuffers();

}

/*

void

Visible(int state)

{

if (state == GLUT_VISIBLE) {

if (moving)

glutIdleFunc(Animate);

} else {

if (moving)

glutIdleFunc(NULL);

}

}

void

timingSelect(int value)

{

switch(value)

{

case 1:

StrMode = GL_VENDOR;

break;

case 2:

StrMode = GL_RENDERER;

break;

case 3:

StrMode = GL_VERSION;

break;

case 4:

StrMode = GL_EXTENSIONS;

break;

}

}

void

menuSelect(int value)

{

switch (value) {

case 1:

moving = GL_TRUE;

glutIdleFunc(Animate);

break;

case 2:

moving = GL_FALSE;

glutIdleFunc(NULL);

break;

case 4:

exit(0);

break;

}

}

int

main(int argc, char **argv)

{

GLboolean fullscreen = GL_FALSE;

GLint time_menu;

srand(0);

glutInit(&argc, argv);

if (argc > 1 && !strcmp(argv[1], "-w"))

fullscreen = GL_FALSE;

//glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);

glutInitDisplayString("rgba double depth=24");

if (fullscreen) {

glutGameModeString("1024x768:32");

glutEnterGameMode();

} else {

glutInitWindowSize(320, 240);

glutCreateWindow("Atlantis Timing");

}

Init();

glutDisplayFunc(Display);

glutReshapeFunc(Reshape);

glutKeyboardFunc(Key);

moving = GL_TRUE;

glutIdleFunc(Animate);

glutVisibilityFunc(Visible);

time_menu = glutCreateMenu(timingSelect);

glutAddMenuEntry("GL_VENDOR", 1);

glutAddMenuEntry("GL_RENDERER", 2);

glutAddMenuEntry("GL_VERSION", 3);

glutAddMenuEntry("GL_EXTENSIONS", 4);

glutCreateMenu(menuSelect);

glutAddMenuEntry("Start motion", 1);

glutAddMenuEntry("Stop motion", 2);

glutAddSubMenu("Timing Mode", time_menu);

glutAddMenuEntry("Quit", 4);

//glutAttachMenu(GLUT_RIGHT_BUTTON);

glutAttachMenu(GLUT_RIGHT_BUTTON);

glutMainLoop();

return 0; // ANSI C requires main to return int.

}

*/