void ViewAndControl::input(unsigned char key, int x, int y) {
if (keys[key].iIntervallHold > Settings::RepeatLock(key))
keys[key].locked = false;
if (!keys[key].locked) {
keys[key].iIntervallHold = 0;
keys[key].locked = true;
switch (key) {
case 27: //esc
glutLeaveGameMode();
Options::WriteCfg();
_exit(0);
//Exit::doIt();
break;
case '+':
GraIngame::zoom(-1);
break;
case '-':
GraIngame::zoom(1);
break;
case 'a':
Village* vil = Village::getVillage(0,0);
vil->allUnits.at(1)->goTo(1,9);
vil->allUnits.at(0)->goTo(5,2);
break; //testing purpose
}
}
}
void Key(unsigned char key, int x, int y)
{
GLint dir = -1;
char str[10];
switch (key) {
case 27: glutLeaveGameMode(); exit(0); break;
// case 'f': glutEnterGameMode(); break;
case 'w': e->pos[1] += 10; break;
case 's': e->pos[1] -= 10; break;
case 'a': e->pos[0] -= 10; break;
case 'd': e->pos[0] += 10; break;
case 'r': angel += 5; break;
case 'f': angel -= 5; break;
case 't': e->dirAbweichung += 0.5; break;
case 'g': if (e->dirAbweichung > 0.5 )e->dirAbweichung -= 0.5; break;
}
e->target[0] = e->pos[0] + 10 * cos(angel/360 * 2 * M_PI);
e->target[1] = e->pos[1] + 10 * sin(angel/360 * 2 * M_PI);
printf("tx %lf ty %lf \n",e->target[0],e->target[1] );
}
void normalKeyboard(unsigned char key, int xx, int yy)
{
glutSetMenu(mainMenu);
switch (key) {
case 27:
glutDestroyMenu(mainMenu);
glutDestroyMenu(fillMenu);
glutDestroyMenu(colorMenu);
glutDestroyMenu(shrinkMenu);
exit(0);
break;
case 's':
if (!menuFlag)
glutChangeToSubMenu(2,"Shrink",shrinkMenu);
break;
case 'c':
if (!menuFlag)
glutChangeToSubMenu(2,"Color",colorMenu);
break;
}
if (key == 27)
if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE) != 0)
glutLeaveGameMode();
exit(0);
}
//<<<<<<<<<<<<<<<<<<<<<<<< myKeyboard >>>>>>>>>>>>>>>>>>>>>>
void myKeyboard(unsigned char key, int x, int y)
{
double moveSpeed = 5.0;
switch(key)
{
// slide controls for camera
case ' '://Fire Everything!!!!!!! (Can Hold it Down)
if(DEBUG == 1){//Only enable "RAMBO" mode for debugging
if(alternate == 0){
ship.fireLeftLaser(&beams);
ship.fireRightLaser(&beams);
alternate++;
}
else{
ship.fireCenterLaser(&beams);
alternate = 0;
}
}
break;
case 27: //Escape key to close the game
glutLeaveGameMode();
exit(0);
break;
}
glutPostRedisplay(); //draw it again
}
void StopEventLoop()
{
if(glutGameModeGet(GLUT_GAME_MODE_ACTIVE)){
glutLeaveGameMode();
}
glutLeaveMainLoop();
}
void Exit()
{
glutLeaveGameMode();
DisplayUnload();
UnloadGame();
exit(0);
}
void scan_keys( unsigned char key, int x, int y )
{
//ESC key to exit
if (key == 27) {
glutLeaveGameMode();
glutLeaveMainLoop();
}
}
void keyboard (unsigned char key, int x, int y) {
if (key == 'f') {
glutEnterGameMode();
} else if (key == 'g') {
printf("leave game mode\n");
glutLeaveGameMode();
} else if (key == 27) {
exit(-1);
}
}
/*
* Closes a window, destroying the frame and OpenGL context
*/
void fgCloseWindow( SFG_Window* window )
{
/* if we're in gamemode and we're closing the gamemode window,
* call glutLeaveGameMode first to make sure the gamemode is
* properly closed before closing the window
*/
if (fgStructure.GameModeWindow != NULL && fgStructure.GameModeWindow->ID==window->ID)
glutLeaveGameMode();
fgPlatformCloseWindow ( window );
}
ScreenGL::~ScreenGL() {
if( mFullScreen ) {
glutLeaveGameMode();
}
delete mViewPosition;
delete mViewOrientation;
delete mRedrawListenerVector;
delete mMouseHandlerVector;
delete mKeyboardHandlerVector;
delete mSceneHandlerVector;
}
void toggleFullscreen() {
if (fullscreen) {
glutLeaveGameMode();
glutInitWindowPosition(50,50);
glutInitWindowSize(1600,1200);
windowId = glutCreateWindow("Lab 4: Loading a textured model");
} else {
glutDestroyWindow(windowId);
glutGameModeString("1600x1200:24");
glutEnterGameMode();
}
}
void keyboard (unsigned char key, int x, int y)
{
if (key=='w')
{
/*float xrotrad, yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xrotrad = (xrot / 180 * 3.141592654f);
xpos += (float)sin(yrotrad) ;
zpos -= (float)cos(yrotrad) ;
ypos -= (float)sin(xrotrad) ;*/
xpos += (float) sin((yrot) * 0.0174532925f) * 5.0f;
zpos += (float) cos((yrot) * 0.0174532925f) * 5.0f;
}
if (key=='s')
{
/*float xrotrad, yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xrotrad = (xrot / 180 * 3.141592654f);
xpos -= (float)sin(yrotrad);
zpos += (float)cos(yrotrad) ;
ypos += (float)sin(xrotrad);*/
xpos -= (float) sin((yrot) * 0.0174532925f) * 5.0f;
zpos -= (float) cos((yrot) * 0.0174532925f) * 5.0f;
}
if (key=='a') //left
{
xpos += (float) sin((yrot + 90) * 0.0174532925f) * 5.0f;
zpos += (float) cos((yrot + 90) * 0.0174532925f) * 5.0f;
}
if (key=='d') // right
{
xpos += (float) sin((yrot - 90) * 0.0174532925f) * 5.0f;
zpos += (float) cos((yrot - 90) * 0.0174532925f) * 5.0f;
}
if (key==27)
{
glutLeaveGameMode(); //set the resolution how it was
exit(0); //quit the program
}
}
/*
* This is a sample idle function
*/
void SampleIdle( void )
{
if( g_LeaveGameMode == 1 )
{
/* One could do all this just as well in SampleGameModeKeyboard... */
printf("leaving gamemode...\n");
glutLeaveGameMode( );
g_LeaveGameMode = 0;
g_InGameMode = 0;
glutPostWindowRedisplay(g_mainwin1);
glutPostWindowRedisplay(g_mainwin2);
glutPostWindowRedisplay(g_sw1);
glutPostWindowRedisplay(g_sw2);
}
}
/*
Function: Process keyPress or keyRelease operations
Flow:
End State:
*/
void keyOperations(void)
{
// Light values
if ( keyStates['r'] ) {
diffuseLightRed = 1.0; //change light to red
diffuseLightGreen = 0.0;
diffuseLightBlue = 0.0;
}
if ( keyStates['g'] ) {
diffuseLightRed = 0.0; //change light to green
diffuseLightGreen = 1.0;
diffuseLightBlue = 0.0;
}
if ( keyStates['b'] ) {
diffuseLightRed = 0.0; //change light to blue
diffuseLightGreen = 0.0;
diffuseLightBlue = 1.0;
}
// Viewer Position
if ( keyStates['w'] )
ViewPositionZ += 0.1;
if ( keyStates['s'] )
ViewPositionZ -= 0.1;
if ( keyStates['a'] )
ViewPositionX += 0.1;
if ( keyStates['d'] )
ViewPositionX -= 0.1;
// Light Position
if ( keyStates['i'] )
lightY += 1.0; //move the light up
if ( keyStates['k'] )
lightY -= 1.0; //move the light down
if ( keyStates['j'] )
lightX -= 1.0; //move the light left
if ( keyStates['l'] )
lightX += 1.0; //move the light right
if (keyStates[27]){
glutLeaveGameMode(); // Reset resolution
exit(0);
}
}
void keyboardDownFunction(unsigned char key, int p1, int p2)
{
if (key == VK_ESCAPE)
{
glutDestroyWindow(g_main_window_id);
exit(0);
}
if (key == 'f')
{
if (!g_fullscreen) {
glutFullScreen();
g_fullscreen = true;
}
else if (g_fullscreen) {
glutLeaveGameMode();
glutLeaveFullScreen();
glutReshapeWindow(g_renderer->_ScreenWidth, g_renderer->_ScreenWidth);
glutPositionWindow(0, 0);
g_fullscreen = false;
}
}
if (key == 'q')
QDown = true;
if (key == 's')
SDown = true;
if (key == 'd')
DDown = true;
if (key == 'z')
ZDown = true;
if (key == 'g')
g_fast_time = !g_fast_time;
if (key == 'c')
camera = !camera;
if (key == VK_SPACE)
avatar->Jump = true;
}
static void Cleanup(void)
{
/* do not handle this signal when cleaning up */
signal(SIGWINCH, SIG_IGN);
if(GameMode)
glutLeaveGameMode();
if(ConsoleFD != -1)
RestoreVT();
/* close mouse */
CloseMouse();
if(Visual)
glutDestroyWindow(1);
/* restore original variable screen info */
if(FrameBufferFD != -1) {
OrigVarInfo.xoffset = 0;
OrigVarInfo.yoffset = 0;
if (ioctl(FrameBufferFD, FBIOPUT_VSCREENINFO, &OrigVarInfo))
fprintf(stderr, "ioctl(FBIOPUT_VSCREENINFO failed): %s\n",
strerror(errno));
if(FrameBuffer)
munmap(FrameBuffer, FixedInfo.smem_len);
close(FrameBufferFD);
}
/* free allocated back buffer */
if(DisplayMode & GLUT_DOUBLE)
free(BackBuffer);
/* free menu items */
FreeMenus();
if(exiterror[0])
fprintf(stderr, "[glfbdev glut] %s", exiterror);
}
/*
* Perform the freeglut deinitialization...
*/
void fgDeinitialize( void )
{
SFG_Timer *timer;
if( !fgState.Initialised )
{
return;
}
/* If we're in game mode, we want to leave game mode */
if( fgStructure.GameModeWindow ) {
glutLeaveGameMode();
}
/* If there was a menu created, destroy the rendering context */
if( fgStructure.MenuContext )
{
fgPlatformDestroyContext (fgDisplay.pDisplay, fgStructure.MenuContext->MContext );
free( fgStructure.MenuContext );
fgStructure.MenuContext = NULL;
}
fgDestroyStructure( );
while( ( timer = fgState.Timers.First) )
{
fgListRemove( &fgState.Timers, &timer->Node );
free( timer );
}
while( ( timer = fgState.FreeTimers.First) )
{
fgListRemove( &fgState.FreeTimers, &timer->Node );
free( timer );
}
fgPlatformDeinitialiseInputDevices ();
fgState.MouseWheelTicks = 0;
fgState.MajorVersion = 1;
fgState.MinorVersion = 0;
fgState.ContextFlags = 0;
fgState.ContextProfile = 0;
fgState.Initialised = GL_FALSE;
fgState.Position.X = -1;
fgState.Position.Y = -1;
fgState.Position.Use = GL_FALSE;
fgState.Size.X = 300;
fgState.Size.Y = 300;
fgState.Size.Use = GL_TRUE;
fgState.DisplayMode = GLUT_RGBA | GLUT_SINGLE | GLUT_DEPTH;
fgState.DirectContext = GLUT_TRY_DIRECT_CONTEXT;
fgState.ForceIconic = GL_FALSE;
fgState.UseCurrentContext = GL_FALSE;
fgState.GLDebugSwitch = GL_FALSE;
fgState.XSyncSwitch = GL_FALSE;
fgState.ActionOnWindowClose = GLUT_ACTION_EXIT;
fgState.ExecState = GLUT_EXEC_STATE_INIT;
fgState.KeyRepeat = GLUT_KEY_REPEAT_ON;
fgState.Modifiers = INVALID_MODIFIERS;
fgState.GameModeSize.X = -1;
fgState.GameModeSize.Y = -1;
fgState.GameModeDepth = -1;
fgState.GameModeRefresh = -1;
fgListInit( &fgState.Timers );
fgListInit( &fgState.FreeTimers );
fgState.IdleCallback = NULL;
fgState.MenuStateCallback = ( FGCBMenuState )NULL;
fgState.MenuStatusCallback = ( FGCBMenuStatus )NULL;
fgState.SwapCount = 0;
fgState.SwapTime = 0;
fgState.FPSInterval = 0;
if( fgState.ProgramName )
{
free( fgState.ProgramName );
fgState.ProgramName = NULL;
}
fgPlatformCloseDisplay ();
fgState.Initialised = GL_FALSE;
}
/*
* Perform the freeglut deinitialization...
*/
void fgDeinitialize( void )
{
SFG_Timer *timer;
if( !fgState.Initialised )
{
return;
}
/* If we're in game mode, we want to leave game mode */
if( fgStructure.GameModeWindow ) {
glutLeaveGameMode();
}
/* If there was a menu created, destroy the rendering context */
if( fgStructure.MenuContext )
{
#if TARGET_HOST_POSIX_X11
/* Note that the MVisualInfo is not owned by the MenuContext! */
glXDestroyContext( fgDisplay.Display, fgStructure.MenuContext->MContext );
#endif
free( fgStructure.MenuContext );
fgStructure.MenuContext = NULL;
}
fgDestroyStructure( );
while( ( timer = fgState.Timers.First) )
{
fgListRemove( &fgState.Timers, &timer->Node );
free( timer );
}
while( ( timer = fgState.FreeTimers.First) )
{
fgListRemove( &fgState.FreeTimers, &timer->Node );
free( timer );
}
#if !defined(_WIN32_WCE)
if ( fgState.JoysticksInitialised )
fgJoystickClose( );
if ( fgState.InputDevsInitialised )
fgInputDeviceClose( );
#endif /* !defined(_WIN32_WCE) */
fgState.JoysticksInitialised = GL_FALSE;
fgState.InputDevsInitialised = GL_FALSE;
fgState.MouseWheelTicks = 0;
fgState.MajorVersion = 1;
fgState.MinorVersion = 0;
fgState.ContextFlags = 0;
fgState.ContextProfile = 0;
fgState.Initialised = GL_FALSE;
fgState.Position.X = -1;
fgState.Position.Y = -1;
fgState.Position.Use = GL_FALSE;
fgState.Size.X = 300;
fgState.Size.Y = 300;
fgState.Size.Use = GL_TRUE;
fgState.DisplayMode = GLUT_RGBA | GLUT_SINGLE | GLUT_DEPTH;
fgState.DirectContext = GLUT_TRY_DIRECT_CONTEXT;
fgState.ForceIconic = GL_FALSE;
fgState.UseCurrentContext = GL_FALSE;
fgState.GLDebugSwitch = GL_FALSE;
fgState.XSyncSwitch = GL_FALSE;
fgState.ActionOnWindowClose = GLUT_ACTION_EXIT;
fgState.ExecState = GLUT_EXEC_STATE_INIT;
fgState.KeyRepeat = GLUT_KEY_REPEAT_ON;
fgState.Modifiers = INVALID_MODIFIERS;
fgState.GameModeSize.X = -1;
fgState.GameModeSize.Y = -1;
fgState.GameModeDepth = -1;
fgState.GameModeRefresh = -1;
fgListInit( &fgState.Timers );
fgListInit( &fgState.FreeTimers );
fgState.IdleCallback = NULL;
fgState.MenuStateCallback = ( FGCBMenuState )NULL;
fgState.MenuStatusCallback = ( FGCBMenuStatus )NULL;
fgState.SwapCount = 0;
fgState.SwapTime = 0;
fgState.FPSInterval = 0;
if( fgState.ProgramName )
{
free( fgState.ProgramName );
fgState.ProgramName = NULL;
}
#if TARGET_HOST_POSIX_X11
/*
* Make sure all X-client data we have created will be destroyed on
* display closing
*/
XSetCloseDownMode( fgDisplay.Display, DestroyAll );
/*
* Close the display connection, destroying all windows we have
* created so far
*/
XCloseDisplay( fgDisplay.Display );
#elif TARGET_HOST_MS_WINDOWS
if( fgDisplay.DisplayName )
{
free( fgDisplay.DisplayName );
fgDisplay.DisplayName = NULL;
}
/* Reset the timer granularity */
timeEndPeriod ( 1 );
#endif
fgState.Initialised = GL_FALSE;
}
void Input::keyUp(unsigned char key,int x,int y){
//TODO: read these keycommands from an xml file
if (!bTextInput){
///W,A,S,D movement Q,E for up/down
if (key=='a' && keyVector.x==-1){
keyVector.x=0;
bPressedMovementKeys=false;
}
if (key=='d' && keyVector.x==1){
keyVector.x=0;
bPressedMovementKeys=false;
}
if (key=='q'){
keyVector.y=0;
bPressedMovementKeys=false;
}
if (key=='e'){
keyVector.y=0;
bPressedMovementKeys=false;
}
if (key=='w'){
Input::keyVector.z=0;
bPressedMovementKeys=false;
}
if (key=='s'){
keyVector.z=0;
bPressedMovementKeys=false;
}
///System stuff
//pressed TAB
if (key==9 || key =='c'){
if (sceneData->controller->tool==TOOL_NAV || sceneData->controller->tool==TOOL_ORBIT){
sceneData->controller->switchTool(sceneData->controller->oldTool);
}else{
sceneData->controller->myTools[TOOL_NAV]->myBtn->clickedLeft();
}
}
//pressed ESC!!!
if (key==27){
Input::deselectButtons(0);
bTextInput=false;
}
//space - run scene
if (key==' ')
sceneData->controller->startMovie();
//pressed Delete!!!
//TODO: this is also implemented in selectTool! Only need one!
if (key==127 || key==8){
if (hudTarget){
Node* n=dynamic_cast<Node*>(hudTarget);
if (n) {
deselectButtons(0);
n->remove();
}
hudTarget=NULL;
}
}
//enable physics simulation p
/*
if (key=='P') //pressed s
renderer->bUpdatePhysics=!renderer->bUpdatePhysics;
*/
//Ctrl-S saves current scene
if (key==19)
sceneData->saveAll(sceneData->currentScene);
///Hotkeys
//trigger selected actor
if (key=='T')
if (sceneData->selectedActors[0])
sceneData->selectedActors[0]->trigger(NULL);
// reload all shaders!
if (key=='S')
sceneData->loadShaders("shaders/","resources/basic.library");
// reload all basic textures!
if (key=='X')
sceneData->loadTextures("resources/icons/","resources/basic.library");
if (key=='v')
sceneData->controller->myTools[TOOL_SELECT]->myBtn->clickedLeft();
/*
if (key=='b'){
renderer->bUseBlending=!renderer->bUseBlending;
cout << "switched blending to: "<<renderer->bUseBlending << endl;
}
*/
if (key=='x'){
if (((BoneWidget*)sceneData->controller->myTools[TOOL_BONE]->myBtn)->bWidgetOpen){
sceneData->controller->switchTool(TOOL_BONE);
}else{
sceneData->controller->myTools[TOOL_BONE]->myBtn->clickedLeft();
}
}
if (key=='z'){
if (((BoneWidget*)sceneData->controller->myTools[TOOL_SKIN]->myBtn)->bWidgetOpen){
sceneData->controller->switchTool(TOOL_SKIN);
}else{
sceneData->controller->myTools[TOOL_SKIN]->myBtn->clickedLeft();
}
}
//switch to grid
if (key=='g'){
sceneData->controller->myTools[TOOL_GRID]->myBtn->clickedLeft();
}
if (key=='h'){
sceneData->grid->bHidden=!sceneData->grid->bHidden;
}
//switch to drawing
if (key=='b'){
if (((DrawingWidget*)sceneData->controller->myTools[TOOL_DRAW]->myBtn)->bWidgetOpen){
sceneData->controller->switchTool(TOOL_DRAW);
}else{
sceneData->controller->myTools[TOOL_DRAW]->myBtn->clickedLeft();
}
}
//switch fullscreen
if (key=='F'){
if (renderer->bFullscreen){
glutLeaveGameMode();
}else{
glutEnterGameMode();
}
renderer->bFullscreen=!renderer->bFullscreen;
}
/*
//create bone
if (key=='k'){
BoneActor* bone = new BoneActor;
bone->setLocation(sceneData->controller->controlledActor->location);
bone->setRotation(sceneData->controller->controlledActor->rotation);
sceneData->actorList.push_back(bone);
}
*/
///debug:
cout << "pressed key: " << (int)key << endl;
///state key update
sceneData->controller->currentTool->keyReleased(key);
}//end !TextInput
}
void keyboardPress(unsigned char pressedKey, int mouseXPosition, int mouseYPosition)
{
switch(pressedKey)
{
case 'w'://VK_UP:
{
camera->moveCamera(movementSpeed);
break;
}
case 'W'://VK_UP:
{
camera->moveCamera(movementSpeed * acceleration);
break;
}
case 's'://VK_DOWN:
{
camera->moveCamera(-movementSpeed);
break;
}
case 'S'://VK_UP:
{
camera->moveCamera(-movementSpeed * acceleration);
break;
}
case 'a'://VK_LEFT:
{
camera->rotateAroundPoint(camera->m_vView, movementSpeed, 0, 1, 0);
break;
}
case 'A'://VK_LEFT:
{
camera->rotateAroundPoint(camera->m_vView, movementSpeed * acceleration, 0, 1, 0);
break;
}
case 'd'://VK_RIGHT:
{
camera->rotateAroundPoint(camera->m_vView, -movementSpeed, 0, 1, 0);
break;
}
case 'D'://VK_RIGHT:
{
camera->rotateAroundPoint(camera->m_vView, -movementSpeed * acceleration, 0, 1, 0);
break;
}
case '+':
{
solarSystem->setRotationSpeed(solarSystem->getRotationSpeed() * 2.0);
break;
}
case '-':
{
solarSystem->setRotationSpeed(solarSystem->getRotationSpeed() * 0.5);
break;
}
case 27:
{
if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE) != 0)
{
glutLeaveGameMode();
exit(0);
}
break;
}
}
}
void pressNormalKeys(unsigned char key, int x, int y)
{
if(key == 27) // ESC
{
destroyObjects();
exit(0);
}
else if(key == '1')
{
glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
}
else if(key == '2')
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
else if(key == '3')
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else if(key == '4'){
turnLinearFogOn();
FOG_ON = 1;
}
else if(key == '5'){
turnExpFogOn();
FOG_ON = 1;
}
else if(key == '6'){
turnExp2FogOn();
FOG_ON = 1;
}
else if(key == '7'){
glDisable(GL_FOG);
FOG_ON = 0;
}
else if((key == 'A') || (key == 'a'))
{
_camera->deltaAnglev = 0.02f;
}
else if((key == 'Z') || (key == 'z'))
{
_camera->deltaAnglev = -0.02f;
}
else if((key == 'S') || (key == 's'))
{
_camera->deltaSpeed = 0.01f;
}
else if((key == 'X') || (key == 'x'))
{
_camera->deltaSpeed = -0.01f;
}
else if((key == 'N') || (key == 'n'))
{
glutLeaveGameMode();
OGLWindow_initWindowMode();
// Inicializações
init();
initCamera();
initLights();
initGameTime();
SSController_Initialize();
// Registar funções de callback
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(display);
glutIgnoreKeyRepeat(1);
glutKeyboardFunc(pressNormalKeys);
glutKeyboardUpFunc(releaseNormalKeys);
glutSpecialFunc(pressSpecialKey);
glutSpecialUpFunc(releaseSpecialKey);
glutMotionFunc(mouseMove);
// - Directly redirect GLUT mouse button events to AntTweakBar
glutMouseFunc((GLUTmousebuttonfun)TwEventMouseButtonGLUT);
// - Directly redirect GLUT mouse "passive" motion events to AntTweakBar (same as MouseMotion)
glutPassiveMotionFunc((GLUTmousemotionfun)TwEventMouseMotionGLUT);
}
else if((key == 'F') || (key == 'f'))
{
OGLWindow_initGameMode();
// Inicializações
init();
initCamera();
initLights();
initGameTime();
SSController_Initialize();
// Registar funções de callback
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(display);
glutIgnoreKeyRepeat(1);
glutKeyboardFunc(pressNormalKeys);
glutKeyboardUpFunc(releaseNormalKeys);
glutSpecialFunc(pressSpecialKey);
glutSpecialUpFunc(releaseSpecialKey);
glutMotionFunc(mouseMove);
// - Directly redirect GLUT mouse button events to AntTweakBar
glutMouseFunc((GLUTmousebuttonfun)TwEventMouseButtonGLUT);
// - Directly redirect GLUT mouse "passive" motion events to AntTweakBar (same as MouseMotion)
glutPassiveMotionFunc((GLUTmousemotionfun)TwEventMouseMotionGLUT);
} else if(key=='U' || key=='u') {
TimeScale -= 10.0f;
} else if(key=='I' || key=='i') {
TimeScale += 10.0f;
} else if(key=='O' || key=='o') {
Planet_setOrbitVisibility(!Planet_getOrbitVisibility());
orbits = !orbits;
} else if(key=='C' || key=='c') {
manualCam = !manualCam;
}
}
Scene::~Scene() {
// Quit fullscreen
if (fullscreen) {
glutLeaveGameMode();
}
}
//fullscreen GameMode creates a new GL context
//currently requires re-registering event callbacks and re-loading texture maps
//------------------------------------------------------------------------------
void npglFullscreen (void* dataRef)
{
int deltaX = 0, deltaY = 0;
int result = 0; //fullscreen window used only if gamemode fails
pData data = (pData) dataRef;
pNPgl gl = &data->io.gl;
if (gl->fullscreen)
{
if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE) != 0) //stereo 3D
{
glutLeaveGameMode();
glutSetWindow (gl->windowID);
glutShowWindow ();
//! register keyboard, mouse and display events with GLUT
npGlutEventFuncs();
npInitGL (data);
}
//exit fullscreen and restore previous window position
gl->fullscreen = false;
glutReshapeWindow (gl->windowSize.x, gl->windowSize.y);
glutPositionWindow (gl->position.x, gl->position.y);
//correct for window border offset, glut workaround
deltaX = gl->position.x - glutGet((GLenum)GLUT_WINDOW_X);
deltaY = gl->position.y - glutGet((GLenum)GLUT_WINDOW_Y);
if (deltaX != 0 || deltaY != 0)
glutPositionWindow (gl->position.x + deltaX,
gl->position.y + deltaY);
npPostMsg("Exit FullScreen", kNPmsgGL, data);
}
else
{
/* glutSetWindow ( gl->windowID);
glutHideWindow ();
//Game Mode with stereo 3D
if (gl->stereo3D)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STEREO); // stereo display mode for glut
else
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
//stereo 3D and GameMode
printf("Attempting Game Mode, please ignore GLUT warnings\n");
glutGameModeString("1920x1080:32@121");
if ( glutEnterGameMode() == 0 )
{
glutGameModeString("1920x1080:32@120");
if ( glutEnterGameMode() == 0 )
{
glutGameModeString("1920x1080:32@119");
if ( glutEnterGameMode() == 0 )
{
glutGameModeString("1920x1080:32@60"); //does not specify refresh
result = ( glutEnterGameMode() );
}}}
*/
gl->position.x = glutGet((GLenum)GLUT_WINDOW_X);
gl->position.y = glutGet((GLenum)GLUT_WINDOW_Y);
gl->windowSize.x = gl->width;
gl->windowSize.y = gl->height;
if (result == 0) //fullscreen window used only if gamemode fails
{
printf("FullScreen Window\n");
glutShowWindow ();
glutFullScreen ();
}
else
{ //GameMode may be different then what we requested, so get the modes
glutSetWindowTitle("ANTz - GameMode");
gl->width = glutGameModeGet( GLUT_GAME_MODE_WIDTH );
gl->height = glutGameModeGet( GLUT_GAME_MODE_HEIGHT );
gl->pixelDepth = glutGameModeGet( GLUT_GAME_MODE_PIXEL_DEPTH );
gl->refreshRate = (float)glutGameModeGet( GLUT_GAME_MODE_REFRESH_RATE );
printf("FullScreen Game Mode: %dx%d:%d@%d\n", gl->width, gl->height,
gl->pixelDepth, (int)gl->refreshRate);
}
gl->fullscreen = true;
}
}
// ------------------------------------------------------------------
// Name : initGlutWindow
// ------------------------------------------------------------------
void DisplayEngine::initGlutWindow()
{
extern bool g_bIgnoreNextResize;
g_bIgnoreNextResize = true;
if (m_iWindow == -2) // was fullscreen
glutLeaveGameMode();
else if (m_iWindow >= 0) // was windowed
{
m_pClientParams->winXPos = glutGet(GLUT_WINDOW_X);
m_pClientParams->winYPos = glutGet(GLUT_WINDOW_Y);
glutDestroyWindow(m_iWindow);
}
extern int g_iOldW;
extern int g_iOldH;
g_iOldW = m_pClientParams->screenXSize;
g_iOldH = m_pClientParams->screenYSize;
if (m_pClientParams->fullscreen)
{
glutGameModeString(m_pClientParams->sGameModeString);
glutEnterGameMode();
m_pClientParams->screenXSize = glutGameModeGet(GLUT_GAME_MODE_WIDTH);
m_pClientParams->screenYSize = glutGameModeGet(GLUT_GAME_MODE_HEIGHT);
m_iWindow = -2;
}
else
{
glutInitWindowPosition(m_pClientParams->winXPos, m_pClientParams->winYPos);
m_pClientParams->screenXSize = m_pClientParams->winWidth;
m_pClientParams->screenYSize = m_pClientParams->winHeight;
glutInitWindowSize(m_pClientParams->screenXSize, m_pClientParams->screenYSize);
m_iWindow = glutCreateWindow("Shahnarman");
}
resizeWindow();
glShadeModel(GL_SMOOTH);
glDisable(GL_BLEND);
glAlphaFunc(GL_GREATER, 0.0001f);
glEnable(GL_ALPHA_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glClearColor(0.1f, 0.05f, 0.1f, 0.0f);
glClearDepth(1.0f);
glClearStencil(0);
GLenum err = glewInit();
if (err != GLEW_OK)
{
char sLog[1024] = "";
snprintf(sLog, 1024, "Error in glewInit: %s.\n", glewGetErrorString(err));
m_pDebug->notifyErrorMessage(sLog);
}
if (!glewIsSupported("GL_ARB_shading_language_100"))
m_pDebug->notifyErrorMessage("Warning: extension GL_ARB_shading_language_100 not supported.");
if (!glewIsSupported("GL_ARB_shader_objects"))
m_pDebug->notifyErrorMessage("Warning: extension GL_ARB_shader_objects not supported.");
if (!glewIsSupported("GL_ARB_vertex_shader"))
m_pDebug->notifyErrorMessage("Warning: extension GL_ARB_vertex_shader not supported.");
if (!glewIsSupported("GL_ARB_fragment_shader"))
m_pDebug->notifyErrorMessage("Warning: extension GL_ARB_fragment_shader not supported.");
Geometry * pGeometry = (Geometry*) m_pRegisteredGeometries->getFirst(0);
while (pGeometry != NULL)
{
pGeometry->reload();
pGeometry = (Geometry*) m_pRegisteredGeometries->getNext(0);
}
if (m_pTexEngine != NULL)
m_pTexEngine->reloadAllTextures();
}
void specialKeyboard(int key, int x, int y)
{
float fraction = 0.2f;
switch(key)
{
case GLUT_KEY_DOWN:
//Code to move DOWN
x -= lx*fraction;
z -= lz*fraction;
break;
case GLUT_KEY_UP:
//Code to move UPWN
x += lx*fraction;
z += lz*fraction;
break;
case GLUT_KEY_LEFT:
//Code to move LEFT
angle1 -= 0.1f;
lx = sin(angle1);
lz = -cos(angle1);
break;
case GLUT_KEY_RIGHT:
//Code to move RIGHT
angle1 += 0.1f;
lx = sin(angle1);
lz = -cos(angle1);
break;
//case GLUT_KEY_F1:
//Code for opening HELP menu
//case GLUT_KEY_F2:
//Code for GAME refresh
case GLUT_KEY_F1:
// define resolution, color depth
glutGameModeString("640x480:32");
// enter full screen
if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) {
glutEnterGameMode();
sprintf(gameModeString,"640x480:32");
// register callbacks again
// and init OpenGL context
init();
}
else
glutGameModeString(gameModeString);
break;
case GLUT_KEY_F2:
// define resolution, color depth
glutGameModeString("800x600:32");
// enter full screen
if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) {
glutEnterGameMode();
sprintf(gameModeString,"800x600:32");
// register callbacks again
// and init OpenGL context
init();
}
else
glutGameModeString(gameModeString);
break;
case GLUT_KEY_F3:
// define resolution, color depth
glutGameModeString("1024x768:32");
// enter full screen
if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) {
glutEnterGameMode();
sprintf(gameModeString,"1024x768:32");
// register callbacks again
// and init OpenGL context
init();
}
else
glutGameModeString(gameModeString);
break;
case GLUT_KEY_F4:
// define resolution, color depth
glutGameModeString("1280x1024:32");
// enter full screen
if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) {
glutEnterGameMode();
sprintf(gameModeString,"1280x1024:32");
// register callbacks again
// and init OpenGL context
init();
}
else
glutGameModeString(gameModeString);
break;
case GLUT_KEY_F5:
// define resolution, color depth
glutGameModeString("1920x1200");
// enter full screen
if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) {
glutEnterGameMode();
sprintf(gameModeString,"1920x1200");
// register callbacks again
// and init OpenGL context
init();
}
else
glutGameModeString(gameModeString);
break;
case GLUT_KEY_F6:
// return to default window
width = 800;height = 600;
if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE) != 0) {
glutLeaveGameMode();
//init();
}
break;
}
if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE) == 0)
sprintf(currentMode,"Current Mode: Window");
else
sprintf(currentMode,
"Current Mode: Game Mode %dx%d at %d hertz, %d bpp",
glutGameModeGet(GLUT_GAME_MODE_WIDTH),
glutGameModeGet(GLUT_GAME_MODE_HEIGHT),
glutGameModeGet(GLUT_GAME_MODE_REFRESH_RATE),
glutGameModeGet(GLUT_GAME_MODE_PIXEL_DEPTH));
}
/*
* Class: gruenewa_opengl_GLUT__
* Method: glutLeaveGameMode
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_gruenewa_opengl_GLUT_00024_glutLeaveGameMode
(JNIEnv * jenv, jobject jobj) {
glutLeaveGameMode();
}
/* ARGSUSED1 */
void
key(unsigned char key, int px, int py)
{
switch (key) {
case 27:
exit(0);
break;
case 'A':
case 'a':
thrust = 1;
thrustTime = glutGet(GLUT_ELAPSED_TIME);
break;
case 'S':
case 's':
shield = 1;
break;
case 'C':
case 'c':
cursor = !cursor;
glutSetCursor(
cursor ? GLUT_CURSOR_INHERIT : GLUT_CURSOR_NONE);
break;
case 'z':
case 'Z':
x = 20;
y = 20;
xv = 0;
yv = 0;
initRocks();
break;
case 'd':
glutGameModeString("1280x1024:32@60");
glutEnterGameMode();
initWindow();
break;
case 'f':
glutGameModeString("640x480:16@60");
glutEnterGameMode();
initWindow();
break;
case 'g':
glutGameModeString("800x600:16@60");
glutEnterGameMode();
initWindow();
break;
case 'h':
if (initialGameModeString) {
glutGameModeString(initialGameModeString);
glutEnterGameMode();
initWindow();
}
break;
case 'l':
if (originalWindow != 0 && currentWindow != originalWindow) {
glutLeaveGameMode();
currentWindow = originalWindow;
}
break;
case 'P':
case 'p':
paused = !paused;
if (paused) {
glutIdleFunc(NULL);
} else {
glutIdleFunc(idle);
resuming = 1;
}
break;
case 'Q':
case 'q':
case ' ':
shotBullet();
break;
case 'i':
printf("%dx%d+%d+%d of depth %d of format %d\n",
glutGet(GLUT_WINDOW_WIDTH),
glutGet(GLUT_WINDOW_HEIGHT),
glutGet(GLUT_WINDOW_X),
glutGet(GLUT_WINDOW_Y),
glutGet(GLUT_WINDOW_BUFFER_SIZE),
glutGet(GLUT_WINDOW_FORMAT_ID));
break;
}
}
int glutEnterGameMode(void)
{
if(ActiveMenu)
return 0;
if(!ModePossible)
return 0;
if(GameMode) {
if(!memcmp(&GameVarInfo, &VarInfo, sizeof VarInfo)) {
DispChanged = 0;
return 1;
}
glutLeaveGameMode();
}
if (ioctl(FrameBufferFD, FBIOPUT_VSCREENINFO, &GameVarInfo))
return 0;
NormVarInfo = VarInfo;
VarInfo = GameVarInfo;
NormVisual = Visual;
SetVideoMode();
CreateVisual();
CreateBuffer();
if(!(GameContext = glFBDevCreateContext(Visual, NULL))) {
sprintf(exiterror, "Failure to create Context\n");
exit(0);
}
if(!glFBDevMakeCurrent( GameContext, Buffer, Buffer )) {
sprintf(exiterror, "Failure to Make Game Current\n");
exit(0);
}
InitializeCursor();
KeyFuncs[0] = KeyboardFunc;
KeyFuncs[1] = KeyboardUpFunc;
NormFuncs[0] = DisplayFunc;
NormFuncs[1] = ReshapeFunc;
NormFuncs[2] = MouseFunc;
NormFuncs[3] = MotionFunc;
NormFuncs[4] = PassiveMotionFunc;
NormFuncs[5] = VisibilityFunc;
NormFuncs[6] = SpecialFunc;
NormFuncs[7] = SpecialUpFunc;
DisplayFunc = NULL;
ReshapeFunc = NULL;
KeyboardFunc = NULL;
KeyboardUpFunc = NULL;
MouseFunc = NULL;
MotionFunc = NULL;
PassiveMotionFunc = NULL;
VisibilityFunc = NULL;
SpecialFunc = SpecialUpFunc = NULL;
DispChanged = 1;
GameMode = 1;
Visible = 1;
VisibleSwitch = 1;
Redisplay = 1;
return 1;
}
void keyboard (unsigned char key, int x, int y) {
if (key=='r')
{
xpos = -8;
ypos = 5;
zpos = 5;
xrot = 0;
yrot = 110;
edit = 0;
randomize = true;
refresh_rate = 0;
}
if (key=='c')
{
clear = true;
}
if (key=='=')
{
// speed up
if (refresh_rate >= 100)
refresh_rate -= 100;
}
if (key=='-')
{
// slow down
refresh_rate += 100;
}
if (key=='0')
{
// step
run_once = true;
}
if (key=='1')
{
// toggle board1 visibility
show_board1 = !show_board1;
}
if (key=='2')
{
// toggle board2 visibility
show_board2 = !show_board2;
}
if (key=='3')
{
// toggle board1 visibility
show_board3 = !show_board3;
}
if (key=='4') {
// toggle classic game of life mode
crossPlanes = !crossPlanes;
}
if (key=='z')
{
ypos --;
}
if (key==' ')
{
ypos ++;
}
if (key=='w')
{
float xrotrad, yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xrotrad = (xrot / 180 * 3.141592654f);
xpos += float(sin(yrotrad));
zpos -= float(cos(yrotrad));
ypos -= float(sin(xrotrad));
}
if (key=='s')
{
float xrotrad, yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xrotrad = (xrot / 180 * 3.141592654f);
xpos -= float(sin(yrotrad));
zpos += float(cos(yrotrad));
ypos += float(sin(xrotrad));
}
if (key=='d')
{
float yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xpos += float(cos(yrotrad));
zpos += float(sin(yrotrad));
}
if (key=='a')
{
float yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xpos -= float(cos(yrotrad));
zpos -= float(sin(yrotrad));
}
if (key==27 || key=='q')
{
glutLeaveGameMode(); //set the resolution how it was
exit(0); //quit the program
}
if (key=='e') {
edit_mode = !edit_mode;
}
if (key=='/') {
board1[edit] = !(board1[edit] || board2[edit] || board3[edit]);
board2[edit] = board1[edit];
board3[edit] = board1[edit];
}
if (key=='p') {
running = !running;
}
if (key=='y') {
wireframe = !wireframe;
}
if (key=='t') {
int model = 0;
glGetIntegerv(GL_SHADE_MODEL, &model);
if (model == (int)GL_SMOOTH)
glShadeModel (GL_FLAT);
else
glShadeModel (GL_SMOOTH);
}
if (key=='f') {
if (fog) {
fog = false;
glDisable(GL_FOG); // Disable GL_FOG
} else {
fog = true;
glEnable(GL_FOG); // Enables GL_FOG
}
}
if (key=='n') {
nurb = !nurb;
}
if (key=='l') {
lighting = !lighting;
if (lighting) {
glEnable(GL_LIGHTING);
} else {
glDisable(GL_LIGHTING);
}
}
if (key=='.') {
editMovePosZ();
}
if (key==',') {
editMoveNegZ();
}
}
// GLUT keyboard function
void keyboardfunc(unsigned char key,int x,int y)
{
float mousex,mousey;
mousex=(float)x/(winwidth-1);
mousey=(float)y/(winwidth-1);
if (mousex<0.0f) mousex=0.0f;
else if (mousex>1.0f) mousex=1.0f;
if (mousey<0.0f) mousey=0.0f;
else if (mousey>1.0f) mousey=1.0f;
switch (key)
{
case ' ':
if (topspeed==0.0) topspeed=speedinc*maxspeed;
else topspeed=0.0;
break;
case 'w':
topspeed+=speedinc*maxspeed;
if (topspeed>maxspeed) topspeed=maxspeed;
break;
case 'W':
topspeed+=speedinc*maxspeed*fast;
if (topspeed>maxspeed*fast) topspeed=maxspeed*fast;
break;
case 'a':
turn-=oneturn;
break;
case 'A':
turn-=oneturn/slow;
break;
case 'd':
turn+=oneturn;
break;
case 'D':
turn+=oneturn/slow;
break;
case 's':
topspeed-=speedinc*maxspeed;
if (topspeed<-maxspeed) topspeed=-maxspeed;
break;
case 'S':
topspeed-=speedinc*maxspeed*fast;
if (topspeed<-maxspeed*fast) topspeed=-maxspeed*fast;
break;
case '<':
incline+=oneincline;
break;
case '>':
incline-=oneincline;
break;
case 'j':
dez=jump;
break;
case 'J':
dez=jump*fast;
break;
case 'g':
if (gravity==0.0) gravity=earthg;
else gravity=0.0;
break;
case 'G':
if (gravity==0.0) gravity=earthg*boost;
else gravity=0.0;
break;
case 't':
tparams->relres1/=1.1f;
if (tparams->relres1<1.0E-3f) tparams->relres1=1.0E-3f;
viewer->propagate();
break;
case 'T':
tparams->relres1*=1.1f;
if (tparams->relres1>1.0E6f) tparams->relres1=1.0E6f;
viewer->propagate();
break;
case 'r':
tparams->relrange1/=1.1f;
if (tparams->relrange1<1.0E-3f) tparams->relrange1=1.0E-3f;
viewer->propagate();
break;
case 'R':
tparams->relrange1*=1.1f;
if (tparams->relrange1>1.0E3f) tparams->relrange1=1.0E3f;
viewer->propagate();
break;
case 'f':
params->farp/=1.1f;
if (params->farp<2*params->nearp) params->farp=2*params->nearp;
viewer->propagate();
break;
case 'F':
params->farp*=1.1f;
if (params->farp>1.0E10f*params->nearp) params->farp=1.0E10f*params->nearp;
viewer->propagate();
break;
case 'v':
params->fovy-=5.0f;
if (params->fovy<10.0f) params->fovy=10.0f;
viewer->propagate();
break;
case 'V':
params->fovy+=5.0f;
if (params->fovy>170.0f) params->fovy=170.0f;
viewer->propagate();
break;
case 'u':
if (tparams->sealevel==-MAXFLOAT) tparams->sealevel=0.0f;
else
{
tparams->sealevel+=0.5f;
if (tparams->sealevel==0.0f) tparams->sealevel=-MAXFLOAT;
}
viewer->propagate();
viewer->getearth()->getterrain()->update();
break;
case 'U':
if (tparams->sealevel==-MAXFLOAT) tparams->sealevel=0.0f;
else
{
tparams->sealevel-=0.5f;
if (tparams->sealevel==0.0f) tparams->sealevel=-MAXFLOAT;
}
viewer->propagate();
viewer->getearth()->getterrain()->update();
break;
case 'm':
eparams->fogdensity*=0.9f;
if (eparams->fogdensity<1.0E-3f) eparams->fogdensity=1.0E-3f;
viewer->propagate();
break;
case 'M':
eparams->fogdensity*=1.1f;
if (eparams->fogdensity>2.0f) eparams->fogdensity=2.0f;
viewer->propagate();
break;
case '9':
if (!eparams->usefog) eparams->usefog=TRUE;
else eparams->usefog=FALSE;
viewer->propagate();
break;
case '8':
if (!eparams->usebathymap) eparams->usebathymap=TRUE;
else eparams->usebathymap=FALSE;
viewer->propagate();
break;
case '7':
if (!eparams->usecontours) eparams->usecontours=TRUE;
else eparams->usecontours=FALSE;
viewer->propagate();
break;
case '6':
if (!eparams->useskydome) eparams->useskydome=TRUE;
else eparams->useskydome=FALSE;
break;
case '5':
if (!eparams->useearth) eparams->useearth=TRUE;
else eparams->useearth=FALSE;
break;
case 'p':
if (!eparams->usewaypoints) eparams->usewaypoints=TRUE;
else eparams->usewaypoints=FALSE;
viewer->propagate();
break;
case 'E':
if (!eparams->useflat) eparams->useflat=TRUE;
else eparams->useflat=FALSE;
viewer->propagate();
break;
case '0':
if (!eparams->nonlin) eparams->nonlin=TRUE;
else eparams->nonlin=FALSE;
viewer->propagate();
break;
case '1':
viewer->getearth()->getterrain()->flatten(1.0f/VIEWER_EXAGGER);
viewer->propagate();
break;
case '2':
viewer->getearth()->getterrain()->flatten(2.0f/VIEWER_EXAGGER);
viewer->propagate();
break;
case '3':
viewer->getearth()->getterrain()->flatten(1.0f);
viewer->propagate();
break;
case '-':
tparams->seatrans=1.0f-tparams->seatrans;
break;
case 'N':
if (!eparams->usenprshader) eparams->usenprshader=TRUE;
else eparams->usenprshader=FALSE;
eparams->usevisshader=!eparams->usenprshader;
viewer->propagate();
break;
case '~':
if (!params->autoadapt) params->autoadapt=TRUE;
else params->autoadapt=FALSE;
break;
case 'l':
if (!params->usewireframe) params->usewireframe=TRUE;
else params->usewireframe=FALSE;
break;
case 'L':
if (!eparams->usediffuse) eparams->usediffuse=TRUE;
else eparams->usediffuse=FALSE;
viewer->propagate();
break;
case 'h':
if (sw_hud==0) sw_hud=1;
else sw_hud=0;
break;
case 'H':
if (sw_hide==0) sw_hide=1;
else sw_hide=0;
break;
case 'c':
if (sw_cross==0) sw_cross=1;
else sw_cross=0;
break;
case 'o':
loadsettings();
break;
case 'O':
savesettings();
break;
case 'P':
screenshot();
break;
case 'Q':
case 27:
delete cam;
delete viewer;
if (sw_full==0) glutDestroyWindow(winid);
else glutLeaveGameMode();
exit(0);
}
wakeup=TRUE;
}
