//called when a key is pressed
void keyboardDown(unsigned char key, int mousePositionX, int mousePositionY)
{
key = tolower(key);
keys[key] = true;
if (key == KEY_ESCAPE) glutExit();
if (key == ' ' && MenOption == 3 && State=="Menu"){
glutExit();
}
}
void keyboardControl(unsigned char key, int x, int y)
{
switch(key) {
case GLUT_KEY_F:
freeCam = !freeCam; break;
case GLUT_KEY_UP:
camMoveSpeed += 0.01; break;
case GLUT_KEY_DOWN:
camMoveSpeed -= 0.01; break;
case GLUT_KEY_J:
ballX += 0.1f; break;
case GLUT_KEY_L:
ballX -= 0.1f; break;
case GLUT_KEY_I:
ballZ += 0.1f; break;
case GLUT_KEY_K:
ballZ -= 0.1f; break;
case GLUT_KEY_H:
glutToggleFullScreen(); break;
case GLUT_KEY_ESC:
glutExit(); break;
// default:
//printf("Key code: %d\n", key);
}
}
static char* textFileRead(const char *fileName) {
char* text = 0;
if (fileName != 0) {
FILE *file = fopen(fileName, "rt");
if (file != 0) {
fseek(file, 0, SEEK_END);
int count = ftell(file);
rewind(file);
if (count > 0) {
text = (char*)malloc(sizeof(char) * (count + 1));
count = fread(text, sizeof(char), count, file);
text[count] = '\0';
}
fclose(file);
}
else {
std::cerr<< "File not found"<<std::endl<<fileName<<std::endl;
#ifdef __APPLE__
exit(0);
#else
glutExit();
#endif
}
}
return text;
}
void
keys(unsigned char c, int x, int y)
{
if (c == 0x1b)
glutExit(); /* escape */
#ifdef STEREO
else switch (c) {
/* adjust stereo3d parallax settings */
case '+': fDxViewpoint += 0.010;
calcStereoMatrix();
break;
case '-': fDxViewpoint -= 0.010;
if (fDxViewpoint < 0.0)
fDxViewpoint = 0.0;
calcStereoMatrix();
break;
case '*': fDxImageShift += 0.001;
calcStereoMatrix();
break;
case '/': fDxImageShift -= 0.001;
calcStereoMatrix();
break;
}
#endif
}
HRESULT CVideoMixerOpenGL::Close()
{
if(!m_bOpen) return E_FAIL;
if(m_pDMCP)
{
m_pDMCP->Close();
m_pDMCP->Release();
m_pDMCP = NULL;
}
EnterCriticalSection(&m_csDisplay);
glutExit();
if(m_hThread)
{
::TerminateThread(m_hThread,0);
m_hThread = NULL;
}
LeaveCriticalSection(&m_csDisplay);
m_hWndParent = NULL;
m_bOpen = false;
return S_OK;
}
//Initialisierungsfunktion
void Initialize(int argc, char* argv[])
{
GLenum GlewInitResult;//neue Variable vom Typ GLenum (um GLEW initialisation zu prüfen)
//initialisiert das anzeige-Window
InitWindow(argc, argv);
glewExperimental = GL_TRUE;//GLEW erhät Informationen zu den Erweiterungen des Grafiktreibers
GlewInitResult = glewInit();//initialisieren von GLEW
//Überprüfen, ob GLEW Initialisierung erfolgreich, wenn nicht wird ein Error geworfen und Programm beendet
if (GLEW_OK != GlewInitResult)
{
fprintf(
stderr,
"ERROR: %s\n",
glewGetErrorString(GlewInitResult)
);
glutExit();
}
//Ausgabe der OpenGL Version
fprintf(
stdout,
"INFO: OpenGL Version: %s\n",
glGetString(GL_VERSION)
);
glGetError();//gibt Fehlerinformationen aus
glClearColor(0.20f, 0.2f, 0.2f, 0.0f); //setzt die Farbe, mit der die Buffer gecleart werden (Parameter bezüglich GLUT_RGBA)
glEnable(GL_DEPTH_TEST);//aktiviert: Tiefenvergleiche und update des Tiefenbuffers (Wenn nicht aktiviert: kein tiefenvergleich, selbst mit aktiviertem Tiefenbuffer)
glDepthFunc(GL_LESS);//Spezifiziert die Variable, die für den Tiefenbuffer genutzt wird (in diesem Fall: wenn Übergebene Tiefenvariable kleiner(Less) als die gespeicherte ist)
ModelViewMatrixStack.loadIdentity();//setzt die aktuelle Matrix als Identitätsmatrix
ProjectionMatrix.setIdentity();//setzt die Projektionsmatrix als Identitätsmatrix
SetupShader();//Lädt und linked die shader
LoadModel();//Lädt modelle
loadTextures();//texturen laden
initParticleSystem();//initialize particle system
std::cout<<"\nChange Shader:\n"<<
"1 - simple Shader\n"<<
"2 - phong Shader\n"<<
"\n"<<
"Particle System:\n"<<
"y - decrease maximum Lifetime of the particles\n"<<
"x - increase maximum Lifetime of the particles\n"<<
"\n"<<
"c - decrease color alpha\n"<<
"v - increase color alpha\n"<<
"\n"<<
"b - decrease particle count\n"<<
"n - increase particle count\n"<<
"\n"<<
"o - increase comet speed\n"<<
"l - decrease comet speed\n";
}
/**************************************************************************//**
* @author Paul Blasi
*
* @par Description:
* Stores the state of the pressed key and does an initial update of the left
* player. Also handles the key presses for space, which pauses, escape, which
* exits the game, and +/-, which incresses and decreases the speed of the ball
* respectively.
*
* @param[in] key - the key that was pressed
* @param[in] x - the x position of the mouse when the key was pressed
* @param[in] y - the y position of the mouse when the key was pressed
*
*****************************************************************************/
void Keyboard(unsigned char key, int x, int y)
{
KEYSTATE[key] = true;
if ((KEYSTATE['w'] || KEYSTATE['W']) && !PAUSED)
{
LEFT_PLAYER.ChangeYSpeed(PADDLE_INC);
}
if ((KEYSTATE['a'] || KEYSTATE['A']) && !PAUSED)
{
LEFT_PLAYER.ChangeXSpeed((-1)*PADDLE_INC);
}
if ((KEYSTATE['s'] || KEYSTATE['S']) && !PAUSED)
{
LEFT_PLAYER.ChangeYSpeed(-1 * PADDLE_INC);
}
if ((KEYSTATE['d'] || KEYSTATE['D']) && !PAUSED)
{
LEFT_PLAYER.ChangeXSpeed(PADDLE_INC);
}
if (KEYSTATE['+'] && !PAUSED)
{
BALL.IncreaseMinVelocity();
}
if (KEYSTATE['-'] && !PAUSED)
{
BALL.DecreaseMinVelocity();
}
if (KEYSTATE[' '])
{
PAUSED = !PAUSED;
if (PAUSED)
{
glutPostRedisplay();
}
else
{
glutTimerFunc(30, Animate, 0);
}
}
if (KEYSTATE[ESCAPE_KEY])
{
glutExit();
}
}
void glut_display()
{
bool signaled_shutdown = false;
if (management_ != nullptr)
{
signaled_shutdown = management_->MainLoop();
glutSwapBuffers();
}
if(signaled_shutdown)
{
glutExit();
exit(0);
}
}
//Ruft alle FreeGLUT Funktionen um ein Window zu öffnen auf
void InitWindow(int argc, char* argv[])
{
//Initialisiert die FreeGLUT lib (ist die erste FreeGLUT Funktion, die aufgerufen werden sollte)
glutInit(&argc, argv);
//*************Angabe des OpenGL Kontextes*************
glutInitContextVersion(3, 3);//OpenGL Version 3.3
glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);//Setzt die Kompatibilität so, dass es auch mit späteren OpenGL Versionen funktioniert
glutInitContextProfile(GLUT_CORE_PROFILE);//nutzt OpenGL nur mit den neuesten Funktionen (compatibility mode = um ältere Versionen zu nutzen)
//*****************************************************
//GLUT_ACTION_ON_WINDOW_CLOSE und GLUT_ACTION_GLUTMAINLOOP_RETURNS bewirkt, dass die mainLoop Funktion das Programm nicht beendet sondern zum Programm zurückkehrt
glutSetOption(
GLUT_ACTION_ON_WINDOW_CLOSE,
GLUT_ACTION_GLUTMAINLOOP_RETURNS
);
//setzt die Größe des render-Fensters
glutInitWindowSize(CurrentWidth, CurrentHeight);
//Displaymode gibt an, wie das Gerät die Szene rendern soll
//GLUT_DEPTH = enthält die Tiefeninformation von Z für jeden Pixel (verhindert, dass neue Objekte nicht Objekte näher an der Kamera überlappen)
//GLUT_DOUBLE = Flag um doppelbuffering zu aktivieren (reduziert flackern - 2 Buffer werden immer wieder Ausgewechselt - einer zum anzeigen, der andere zum rendern)
//GLUT_RGBA = Flag um Farbkompositionen anzugeben (RGBA = Rot, Grün, Blau, Alpha)
//es sind mehrere zusätzliche Optionen möglich
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
//erstellt ein Window und speichert das Handle dazu in WindowHandle (Parameter ist Window Title String)
WindowHandle = glutCreateWindow("Test");
//Handle checken, ob er kleiner als 1 ist, wenn ja wird Error geworfen und Programm beendet
if(WindowHandle < 1)
{
fprintf(
stderr,
"ERROR: Could not create a new rendering window.\n"
);
glutExit();
}
//Glut function callbacks
//TODO: add keyboard and mouse functions
glutTimerFunc(0, TimerFunction, 0); //startet direkt die Funktion TimerFunction und übergibt 0 (damit der Titel am anfang nicht geändert wird)
glutReshapeFunc(ResizeFunction); //wird jedes mal aufgerufen, wenn das Window verkleinert oder vergrößert wird
glutDisplayFunc(RenderFunction); //wird jedes mal ausgeführt, wenn die szene auf den Bildschirm gezeichnet werden soll
glutIdleFunc(IdleFunction); //macht die Idle Funktion bekannt
glutKeyboardFunc(KeyEventProcessing);
}
void keyboardControl(unsigned char key, int x, int y)
{
vec3 camRight = Normalize(CrossProduct(camDir, camUp));
mat4 rot;
switch(key) {
case GLUT_KEY_F:
rot = ArbRotate(camRight, CAM_ROT_SPEED);
camDir = Normalize(MultVec3(rot, camDir)); break;
case GLUT_KEY_H:
glutToggleFullScreen(); break;
case GLUT_KEY_ESC:
glutExit(); break;
// default:
//printf("Key code: %d\n", key);
}
}
/* ARGSUSED1 */
void parsekey(unsigned char key, int x, int y)
{
switch (key)
{
case 27: glutExit(); break;
case 13: break;
case ' ': progress = 1; randomize(); break;
#ifdef STEREO
/* update stereo parallax settings */
case '+': dxViewpt += 0.100; break;
case '-': dxViewpt -= 0.100; break;
case '*': dxAdjust += 0.0001; break;
case '/': dxAdjust -= 0.0001; break;
case 's': stereo = (stereo) ? 0 : 1; break;
#endif
}
}
void glut_wrapper::keyboard(unsigned char key, int x, int y)
{
switch(key)
{
case 27:
glutExit();
exit(0);
break;
case '.':
glutFullScreenToggle();
break;
default:
if (glut_wrapper::manager != nullptr)
{
glut_wrapper::manager->dispatchKeyboardInput(key);
}
break;
}
}
void glut_keyboard(unsigned char key, int x, int y)
{
switch(key)
{
case 27:
//Cleanup();
glutExit();
exit(0);
break;
case '.':
if(!quality_measurement_mode_enabled_)
glutFullScreenToggle();
break;
default:
if (management_ != nullptr)
{
management_->dispatchKeyboardInput(key);
}
break;
}
}
void mouse(int button, int state, int x, int y)
{
glutExit();
}
void glut_wrapper::quit()
{
glutExit();
}
// All key events are processed here
void WorldDrawer::keyOperations()
{
if (keyStates[KEY_ESC]) // On Escape, program exits
glutExit();
float rotateStep = 0.04f;
float moveStep = 0.25f;
if (camera.mode == MODE_FPS)
{
if (keySpecialStates[KEY_UP]) // Rotate FPS up
{
camera.rotateFPS_OX(-rotateStep);
}
if (keySpecialStates[KEY_DOWN]) // Rotate FPS down
{
camera.rotateFPS_OX(rotateStep);
}
if (keySpecialStates[KEY_LEFT]) // Rotate FPS left
{
camera.rotateFPS_OY(-rotateStep);
}
if (keySpecialStates[KEY_RIGHT]) // Rotate FPS right
{
camera.rotateFPS_OY(rotateStep);
}
}
else if (camera.mode == MODE_TPS)
{
if (keySpecialStates[KEY_UP]) // Rotate TPS up
{
camera.rotateTPS_OX(-rotateStep, distanceToTPSTarget);
}
if (keySpecialStates[KEY_DOWN]) // Rotate TPS down
{
camera.rotateTPS_OX(rotateStep, distanceToTPSTarget);
}
if (keySpecialStates[KEY_LEFT]) // Rotate TPS left
{
camera.rotateTPS_OY(-rotateStep, distanceToTPSTarget);
}
if (keySpecialStates[KEY_RIGHT]) // Rotate TPS right
{
camera.rotateTPS_OY(rotateStep, distanceToTPSTarget);
}
}
else if (camera.mode == MODE_TOP)
{
if (keySpecialStates[KEY_LEFT]) // Rotate left
{
camera.rotateTPS_OY(-rotateStep, distanceToTop);
}
if (keySpecialStates[KEY_RIGHT]) // Rotate right
{
camera.rotateTPS_OY(rotateStep, distanceToTop);
}
}
float eyeDistanceStep = 1.f;
// Zoom closer
if (keyStates['['])
{
eyeDistance -= eyeDistanceStep; // Move closer to the viewer
if (camera.mode == MODE_TPS && distanceToTPSTarget - zoomSensivity > 0)
{
distanceToTPSTarget -= zoomSensivity;
camera.translate_ForwardFree(zoomSensivity);
}
else if (camera.mode == MODE_TOP && distanceToTop - zoomSensivity * 20 > 0)
{
distanceToTop -= zoomSensivity * 20;
camera.translate_ForwardFree(zoomSensivity * 20);
}
}
if (keyStates[']'])
{
eyeDistance += eyeDistanceStep; // Move farther from the viewer
if (camera.mode == MODE_TPS)
{
distanceToTPSTarget += zoomSensivity;
camera.translate_ForwardFree(-zoomSensivity);
}
else if (camera.mode == MODE_TOP)
{
distanceToTop += zoomSensivity * 20;
camera.translate_ForwardFree(-zoomSensivity * 20);
}
}
if (keyStates['w']) // Move forward
{
camera.translate_Forward(moveStep);
// Check colision
Vector3D newPos = getPlayerPosition();
std::vector<Point2d> neighbours = labyrinth.getNeighbours(labyrinth.playerPos);
bool updatedCell = labyrinth.updateCell(neighbours, newPos);
if (labyrinth.foundPortal())
{
Sleep(1000);
int mode = camera.mode;
switchCameraMode(MODE_FPS);
init();
switchCameraMode(mode);
}
if (!updatedCell)
{
for (unsigned int i = 0; i < neighbours.size(); ++i)
if (labyrinth.isColision(neighbours[i], newPos))
{
camera.translate_Forward(-moveStep);
}
}
}
if (keyStates['s']) // Move backwards
{
camera.translate_Forward(-moveStep);
// Check colision
Vector3D newPos = getPlayerPosition();
std::vector<Point2d> neighbours = labyrinth.getNeighbours(labyrinth.playerPos);
bool updatedCell = labyrinth.updateCell(neighbours, newPos);
if (labyrinth.foundPortal())
{
Sleep(1000);
int mode = camera.mode;
switchCameraMode(MODE_FPS);
init();
switchCameraMode(mode);
}
if (!updatedCell)
{
for (unsigned int i = 0; i < neighbours.size(); ++i)
if (labyrinth.isColision(neighbours[i], newPos))
{
camera.translate_Forward(moveStep);
}
}
}
if (keyStates['a']) // Move left
{
camera.translate_Right(-moveStep);
// Check colision
Vector3D newPos = getPlayerPosition();
std::vector<Point2d> neighbours = labyrinth.getNeighbours(labyrinth.playerPos);
bool updatedCell = labyrinth.updateCell(neighbours, newPos);
if (labyrinth.foundPortal())
{
Sleep(1000);
int mode = camera.mode;
switchCameraMode(MODE_FPS);
init();
switchCameraMode(mode);
}
if (!updatedCell)
{
for (unsigned int i = 0; i < neighbours.size(); ++i)
if (labyrinth.isColision(neighbours[i], newPos))
{
camera.translate_Right(moveStep);
}
}
}
if (keyStates['d']) // Move right
{
camera.translate_Right(moveStep);
// Check colision
Vector3D newPos = getPlayerPosition();
std::vector<Point2d> neighbours = labyrinth.getNeighbours(labyrinth.playerPos);
bool updatedCell = labyrinth.updateCell(neighbours, newPos);
if (labyrinth.foundPortal())
{
Sleep(1000);
int mode = camera.mode;
switchCameraMode(MODE_FPS);
init();
switchCameraMode(mode);
}
if (!updatedCell)
{
for (unsigned int i = 0; i < neighbours.size(); ++i)
if (labyrinth.isColision(neighbours[i], newPos))
{
camera.translate_Right(-moveStep);
}
}
}
}
void teclado(unsigned char c, int x, int y) {
(void)x;(void)y;
switch (c) {
case 27:
glutExit();
break;
case 'h':
help; //Nesisito aiuda amiho servesa bier
std::cout << "You can see the state of the camera type on the up left corner." << std::endl;
std::cout << "Press H to display the help(lolol)" << std::endl;
std::cout << "Press R to reset the camera" << std::endl;
std::cout << "Press P to switch between perspective and ortho camera" << std::endl;
std::cout << "Press C to switch between first person camera and third person camera" << std::endl;
std::cout << "Press WASD to move the Patricio" << std::endl;
std::cout << "Press Z or X to increment/decrement the speed of the Patricio" << std::endl;
std::cout << "Press V to make the walls visible/invisible" << std::endl;
std::cout << "Press B to make the sfere of the scene visible/invisible" << std::endl;
std::cout << "Press M to switch the model of the main character" << std::endl;
std::cout << "Press O to change the polygon mode" << std::endl;
std::cout << "Press Space to unleash the hidden and destructive power of the Killer Patricio" << std::endl;
std::cout << std::endl;
break;
case 'w':
patricio1.posFinal = patricio1.posFinal + Vector3f(sin(direccionPatricio*M_PI/180)*speed,0,cos(direccionPatricio*M_PI/180)*speed);
updateCamera(); // Por si el patricio se ha salido de la esfera i ase iorar al ninio jisus
glutPostRedisplay();
break;
case 's':
patricio1.posFinal = patricio1.posFinal - Vector3f(sin(direccionPatricio*M_PI/180)*speed,0,cos(direccionPatricio*M_PI/180)*speed);
updateCamera(); // Por si el patricio se ha salido de la esfera i ase iorar al ninio jisus
glutPostRedisplay();
break;
case 'a':
direccionPatricio += 2.5;
if (fps) updateCamera();
else glutPostRedisplay();
break;
case 'd':
direccionPatricio -= 2.5;
if (fps) updateCamera();
else glutPostRedisplay();
break;
case 'z':
speed += 0.03;
break;
case 'x':
speed -= 0.03; if (speed < 0) speed = 0;
break;
case 'r':
reset();
glutPostRedisplay();
break;
case 'c':
fps = not fps;
if (fps) changeCamera(Fps);
else changeCamera(ortho ? Ortho : Perspective);
updateCamera();
break;
case 'p':
if (cameraState != Fps) changeCamera(CameraType((cameraState+1)%(qttCameraType-1)));
updateCameraType();
break;
case 'o':
changeShowing(Showing((showing+1)%qttShowing));
break;
case 'm':
patricio1.changeModel(Models((patricio1.name+1)%qttModels));
glutPostRedisplay();
break;
case 'v':
wallVisible = not wallVisible;
glutPostRedisplay();
break;
case 'b':
sferaVisible = not sferaVisible;
glutPostRedisplay();
break;
case ' ':
balas.push_back(Bala(patricio1.posFinal,direccionPatricio));
break;
default:
break;
}
}
void WorldDrawer2d::keyboardCallbackFunction(unsigned char key, int posx, int posy){
if(key==KEY_ESC) glutExit();
//call client function
onKey(key);
}
//used to handle all user input
void handleInput(int deltatime)
{
float deltaseconds = deltatime / 1000.0f;
if (State == "Play"){
Time += deltaseconds;
glutSetCursor(GLUT_CURSOR_NONE);
glutPassiveMotionFunc(setMouse);
glutWarpPointer(win1.width / 2, win1.height / 2);
float mouseSpeed = 5;
float xAngle = mouseSpeed * deltaseconds * float(win1.width / 2 - mPosX);
float yAngle = mouseSpeed * deltaseconds * float(win1.height / 2 - mPosY);
camera1->mouseLook(xAngle, yAngle);
cylinder1.yaw(-xAngle);
if (keys['w']) {
if (!jumping)
PlaySound(TEXT("step.wav"), NULL, SND_FILENAME | SND_ASYNC| SND_NOSTOP);
camera1->move(deltaseconds * (15 + boost));
distanceFromMaze = checkCollision(toClosestEdge);
if (distanceFromMaze > 4.0){
handleCollision();
}
moveTime++;
if (moveTime > 30){
legAngle *= -1;
moveTime = 0;
}
thighLeft.pitch(legAngle);
thighRight.pitch(-legAngle);
}
else{
moveTime = 15;
thighLeft.resetOrientation();
thighRight.resetOrientation();
}
if (keys['f']){
savePlayer = cylinder1;
savePoint = camera1->getPosition();
saveUP = camera1->getCameraUp();
saveFOR = camera1->getForward();
savePoint.y = 2;
hasSavePoint = true;
keys['f'] = false;
}
if (keys['g'] && hasSavePoint){
cylinder1 = savePlayer;
camera1->setPosition(savePoint);
camera1->setCameraUp(saveUP);
camera1->setForward(saveFOR);
keys['g'] = false;
}
if (keys['s']){
if (!jumping)
PlaySound(TEXT("step.wav"), NULL, SND_FILENAME | SND_ASYNC | SND_NOSTOP);
camera1->move(-deltaseconds * (15 + boost));
distanceFromMaze = checkCollision(toClosestEdge);
if (distanceFromMaze > 4.0){
handleCollision();
}
}
if (keys['a']) {
if (!jumping)
PlaySound(TEXT("step.wav"), NULL, SND_FILENAME | SND_ASYNC | SND_NOSTOP);
camera1->strafe(-deltaseconds * (15 + boost));
distanceFromMaze = checkCollision(toClosestEdge);
if (distanceFromMaze > 4.0){
handleCollision();
}
}
if (keys['d']) {
if (!jumping)
PlaySound(TEXT("step.wav"), NULL, SND_FILENAME | SND_ASYNC | SND_NOSTOP);
camera1->strafe(deltaseconds * (15 + boost));
distanceFromMaze = checkCollision(toClosestEdge);
if (distanceFromMaze > 4.0){
handleCollision();
}
}
if (keys['p']) {
State = "Menu";
isPaused = true;
}
if (keys[' '] && Stamina > 5 && !jumping) {
PlaySound(TEXT("jump.wav"), NULL, SND_FILENAME | SND_ASYNC );
jumping = true;
Stamina -= 5;
keys[' '] = false;
}
if (jumping) camera1->jump(deltaseconds * 10);
if (camera1->getPosition().y <= 2){
camera1->setPosition(Vector3(camera1->getPosition().x, 2, camera1->getPosition().z));
jumping = false;
camera1->gravity = 0.25;
}
if (special[GLUT_KEY_SHIFT_L] && Stamina > 0){
Stamina -= (0.001 / deltaseconds);
if (Stamina < 0){
Stamina = 0;
boost = 0;
}
else{
boost = 10;
}
}
else{
boost = 0;
Stamina += (0.001 / deltaseconds);
if (Stamina >= 100){
Stamina = 100;
}
}
}
if (State == "Menu"){
if (!isPaused){
if (special[GLUT_KEY_UP]){
MenOption--;
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
special[GLUT_KEY_UP] = false;
if (MenOption < 0){
MenOption = 3;
}
}
if (special[GLUT_KEY_DOWN]){
MenOption++;
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
special[GLUT_KEY_DOWN] = false;
if (MenOption > 3){
MenOption = 0;
}
}
}
else{
if (special[GLUT_KEY_UP]){
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
MenOption--;
special[GLUT_KEY_UP] = false;
if (MenOption < 0){
MenOption = 4;
}
}
if (special[GLUT_KEY_DOWN]){
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
MenOption++;
special[GLUT_KEY_DOWN] = false;
if (MenOption > 4){
MenOption = 0;
}
}
}
if (keys[' '] && MenOption == 0){
PlaySound(TEXT("play.wav"), NULL, SND_FILENAME | SND_ASYNC);
if (!isPaused)
State = "Loading";
else
State = "Play";
keys[' '] = false;
isPaused = false;
}
if (keys[' '] && MenOption == 1){
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
State = "Controls";
keys[' '] = false;
}
if (keys[' '] && MenOption == 2){
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
State = "Credits";
keys[' '] = false;
}
if (keys[' '] && MenOption == 3){
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
glutExit();
}
if (keys[' '] && MenOption == 4){
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
Stamina = 100;
camera1 = new Camera(Vector3(levels[currLevel]->startPoint->x, 2, levels[currLevel]->startPoint->y), findPosition(levels[currLevel]), Vector3(0, 1, 0));
State = "Loading";
keys[' '] = false;
isPaused = false;
}
}
if (State == "Credits"){
if (keys[' ']){
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
State = "Menu";
keys[' '] = false;
}
}
if (State == "Controls"){
if (keys[' ']){
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
State = "Menu";
keys[' '] = false;
}
}
if (State == "Loading"){
if (keys[' ']){
PlaySound(TEXT("switch.wav"), NULL, SND_FILENAME | SND_ASYNC);
State = "Play";
keys[' '] = false;
}
}
}
