maj/OpenArena
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixes to compile on linux.

Browse Source 
Windows is still broken.
~Tom
This commit is contained in:
Tom Hicks
2006-10-17 01:49:50 -04:00
parent 02143f21eb
commit c8f0d9588f
8 changed files with 70 additions and 717 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/Makefile.linux
View File

@@ -2,7 +2,9 @@
CPP = g++ -g CPP = g++ -g
INCLUDES = -I/usr/X11R6/include INCLUDES = -I/usr/X11R6/include
LD = g++ LD = g++
OBJECTS = screen.o bmp.o camera.o ctrls.o level.o mygl.o myglFont.o myglTexture.o player.o strmanip.o tga.o vector.o window.o keys.o main.o OBJECTS = screen.o bmp.o camera.o ctrls.o level.o mygl.o myglFont.o myglTexture.o player.o
OBJECTS += strmanip.o tga.o vector.o window.o keys.o main.o x11.o EventManager.o Events/DrawEvent.o
OBJECTS += Events/Event.o Object.o Events/KeyPressEvent.o Events/KeyReleaseEvent.o
LIBS = -L/usr/X11R6/lib -lGL -lGLU -lXxf86vm LIBS = -L/usr/X11R6/lib -lGL -lGLU -lXxf86vm
LIBRARIES = LIBRARIES =
SO_LIBS = SO_LIBS =
@@ -36,6 +38,21 @@ oa_video.so:
oa_input.so: oa_input.so:
#Object Files #Object Files
Events/Event.o: Events/Event.cpp Events/Event.h Object.h
$(CPP) $(CPPFLAGS) -c $(INCLUDE_DIRS) -o Events/Event.o Events/Event.cpp
Object.o: Object.cpp Object.h
$(CPP) $(CPPFLAGS) -c $(INCLUDE_DIRS) -o Object.o Object.cpp
Events/KeyPressEvent.o: Events/KeyPressEvent.cpp Events/KeyPressEvent.h Events/Event.h
$(CPP) $(CPPFLAGS) -c $(INCLUDE_DIRS) -o Events/KeyPressEvent.o Events/KeyPressEvent.cpp
Events/KeyReleaseEvent.o: Events/KeyReleaseEvent.cpp Events/KeyReleaseEvent.h Events/Event.h
$(CPP) $(CPPFLAGS) -c $(INCLUDE_DIRS) -o Events/KeyReleaseEvent.o Events/KeyReleaseEvent.cpp
Events/DrawEvent.o: Events/DrawEvent.cpp Events/DrawEvent.h Events/Event.h
$(CPP) $(CPPFLAGS) -c $(INCLUDE_DIRS) -o Events/DrawEvent.o Events/DrawEvent.cpp
screen.o: screen.cpp screen.h config.h screen.o: screen.cpp screen.h config.h
$(CPP) $(CPPFLAGS) -c -o screen.o screen.cpp $(CPP) $(CPPFLAGS) -c -o screen.o screen.cpp

756
src/linux.cpp
View File

@@ -51,33 +51,19 @@
//include necessary header files //include necessary header files
#include "main.h" #include "main.h"
#include "version.h" #include "version.h"
#include "x11.h"
using namespace std; using namespace std;
void InitControls(); void InitControls();
unsigned char TranslateKey(int keyCode);
unsigned char TranslateButton(int keyCode);
void HandleConsoleKeyPress(OpenArena::Keys key);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function Definitions // Function Definitions
void ResizeGLScene(GLsizei width, GLsizei height) int DrawGLScene(OpenArena::Level* level)
{ {
if(height == 0) level->Render();
height = 1;
glViewport(0,0,width, height); g_Screen->SwapBuffers();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, (GLfloat)width/height, 0.1f, 100.0f);
glMatrixMode(GL_MODELVIEW);
}
int DrawGLScene()
{
level.Render();
g_Screen.SwapBuffers();
return true; return true;
} }
@@ -86,46 +72,16 @@ int DrawGLScene()
//void InitControls() //void InitControls()
// Purpose: // Purpose:
// Initializes controls by loading the default control config file "my.cfg". // Initializes controls by loading the default control config file "my.cfg".
void InitControls() void InitControls(OpenArena::Level* level)
{ {
if (!level.LoadConfig("my.cfg")) if (!level->LoadConfig("my.cfg"))
level.LoadConfig(); level->LoadConfig();
}
//
//int InitGL(GLvoid)
// Purpose:
// To do all required setup before creating an OpenGL window
int InitGL(GLvoid)
{
level.LoadGLTextures();
glEnable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
/*lighting disabled temporarily
glLightfv(GL_LIGHT1, GL_AMBIENT, level.LightAmbient);
for(index=0; index<level.numLights; index++)
{
glLightfv(GL_LIGHT1, GL_DIFFUSE, level.light[index].color);
glLightfv(GL_LIGHT1, GL_POSITION, level.light[index].coords);
}
glEnable(GL_LIGHT1);
glEnable(GL_LIGHTING);
*/
//BuildFont();
return true;
} }
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
OpenArena::EventManager* em = new OpenArena::EventManager();
OpenArena::Level* level = new OpenArena::Level(em);
XEvent event; XEvent event;
bool done = false; bool done = false;
@@ -135,43 +91,43 @@ int main(int argc, char** argv)
{ {
commandLine = commandLine + " " + argv[i]; commandLine = commandLine + " " + argv[i];
} }
level.ParseCmds(commandLine.c_str()); level->ParseCmds(commandLine.c_str());
InitControls(); InitControls(level);
level.glFont.SetScreenDimensions(level.screen.GetWidth()*2, level.screen.GetHeight()*2); level->glFont.SetScreenDimensions(level->screen.GetWidth()*2, level->screen.GetHeight()*2);
//Hack for now //Hack for now
if(level.screen.GetColorDepth() == 32) if(level->screen.GetColorDepth() == 32)
{ {
level.screen.SetColorDepth(24); level->screen.SetColorDepth(24);
} }
// g_Screen.SetOnInit(InitGL); // g_Screen.SetOnInit(InitGL);
// g_Screen.SetOnResize(ResizeGLScene); // g_Screen.SetOnResize(ResizeGLScene);
if(!g_Screen.Open(OPENARENA_VERSION, level.screen.GetWidth(), level.screen.GetHeight(), level.screen.GetColorDepth(), level.screen.GetFullscreen())) if(!g_Screen->Open(OPENARENA_VERSION, level->screen.GetWidth(), level->screen.GetHeight(), level->screen.GetColorDepth(), level->screen.GetFullscreen()))
{ {
return 1; return 1;
} }
level.SetWindow(&g_Screen); level->SetWindow(g_Screen);
if(level.nextLevel == "") if(level->nextLevel == "")
{ {
level.LoadMap("intro.map"); level->LoadMap("intro.map");
} }
else else
{ {
level.LoadMap(); level->LoadMap();
} }
while(!done) while(!done)
{ {
while(XPending(g_Screen.GetDisplay()) > 0) while(XPending(g_Screen->GetDisplay()) > 0)
{ {
//Equivalent of WNDPROC //Equivalent of WNDPROC
XNextEvent(g_Screen.GetDisplay(), &event); XNextEvent(g_Screen->GetDisplay(), &event);
switch(event.type) switch(event.type)
{ {
case Expose: case Expose:
@@ -179,13 +135,13 @@ int main(int argc, char** argv)
{ {
break; break;
} }
DrawGLScene(); DrawGLScene(level);
break; break;
case ConfigureNotify: case ConfigureNotify:
if((event.xconfigure.width != g_Screen.GetWidth()) || (event.xconfigure.height != g_Screen.GetHeight())) if((event.xconfigure.width != g_Screen->GetWidth()) || (event.xconfigure.height != g_Screen->GetHeight()))
{ {
g_Screen.SetWidth(event.xconfigure.width); g_Screen->SetWidth(event.xconfigure.width);
g_Screen.SetHeight(event.xconfigure.height); g_Screen->SetHeight(event.xconfigure.height);
ResizeGLScene(event.xconfigure.width, event.xconfigure.height); ResizeGLScene(event.xconfigure.width, event.xconfigure.height);
} }
break; break;
@@ -197,9 +153,9 @@ int main(int argc, char** argv)
keys2[TranslateButton(event.xbutton.button)] = false; keys2[TranslateButton(event.xbutton.button)] = false;
break; break;
case KeyPress: case KeyPress:
if(level.showConsole) if(level->showConsole)
{ {
HandleConsoleKeyPress((OpenArena::Keys)TranslateKey(XLookupKeysym(&event.xkey, 0))); HandleConsoleKeyPress((OpenArena::Keys)TranslateKey(XLookupKeysym(&event.xkey, 0)), level);
} }
else else
{ {
@@ -211,7 +167,7 @@ int main(int argc, char** argv)
keys2[TranslateKey(XLookupKeysym(&event.xkey, 0))] = false; keys2[TranslateKey(XLookupKeysym(&event.xkey, 0))] = false;
break; break;
case ClientMessage: case ClientMessage:
if(*XGetAtomName(g_Screen.GetDisplay(), event.xclient.message_type) == *"WM_PROTOCOLS") if(*XGetAtomName(g_Screen->GetDisplay(), event.xclient.message_type) == *"WM_PROTOCOLS")
{ {
printf("Exiting sanely...\n"); printf("Exiting sanely...\n");
done = true; done = true;
@@ -230,682 +186,62 @@ int main(int argc, char** argv)
} }
else if(keys[OpenArena::KEY_F1]) else if(keys[OpenArena::KEY_F1])
{ {
g_Screen.Close(); g_Screen->Close();
g_Screen.ToggleFullscreen(); g_Screen->ToggleFullscreen();
g_Screen.Open(); g_Screen->Open();
} }
else else
{ {
level.defaultPlayer[0].camera.Update(); level->defaultPlayer[0].camera.Update();
if(!level.showConsole) if(!level->showConsole)
{ {
if(level.mlook) if(level->mlook)
{ {
using OpenArena::Vec2i; using OpenArena::Vec2i;
Vec2i middleOfScreen = Vec2i(g_Screen.GetWidth()/2, g_Screen.GetHeight()/2); Vec2i middleOfScreen = Vec2i(g_Screen->GetWidth()/2, g_Screen->GetHeight()/2);
Vec2i mousePosition = g_Screen.GetMousePosition(); Vec2i mousePosition = g_Screen->GetMousePosition();
if(mousePosition != middleOfScreen) if(mousePosition != middleOfScreen)
{ {
//Vec2i mouseDelta = mousePosition - middleOfScreen; //Vec2i mouseDelta = mousePosition - middleOfScreen;
Vec2i mouseDelta = middleOfScreen - mousePosition; Vec2i mouseDelta = middleOfScreen - mousePosition;
g_Screen.SetMousePosition(middleOfScreen); g_Screen->SetMousePosition(middleOfScreen);
const float MOUSE_SENSITIVITY_HORIZONTAL = 0.005; const float MOUSE_SENSITIVITY_HORIZONTAL = 0.005;
const float MOUSE_SENSITIVITY_VERTICAL = 0.005; const float MOUSE_SENSITIVITY_VERTICAL = 0.005;
float horizontalAngle = mouseDelta.x * MOUSE_SENSITIVITY_HORIZONTAL; float horizontalAngle = mouseDelta.x * MOUSE_SENSITIVITY_HORIZONTAL;
float verticalAngle = mouseDelta.y * MOUSE_SENSITIVITY_VERTICAL; float verticalAngle = mouseDelta.y * MOUSE_SENSITIVITY_VERTICAL;
level.defaultPlayer[0].camera.RotateHorizontal(horizontalAngle); level->defaultPlayer[0].camera.RotateHorizontal(horizontalAngle);
level.defaultPlayer[0].camera.RotateVertical(verticalAngle); level->defaultPlayer[0].camera.RotateVertical(verticalAngle);
} }
} }
else else
{ {
#ifdef WIN32 #ifdef WIN32
SetCursorPos(g_Screen.width/2, g_Screen.height/2);//Shit this may be windows specific SetCursorPos(g_Screen->width/2, g_Screen->height/2);//Shit this may be windows specific
#endif #endif
} }
//Maybe some of these if not almost all should be moved into Level
//////////
//Move Backward
if(!level.defaultPlayer->controls.backward.IsEmpty())
{
level.defaultPlayer->controls.backward.FirstPosition();
if(keys[level.defaultPlayer->controls.backward.Retrieve()])
{
level.defaultPlayer->camera.MoveCamera(-level.moveSpeed);
}
else
{
while(level.defaultPlayer->controls.backward.NextPosition() && (keys[level.defaultPlayer->controls.backward.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.backward.Retrieve()])
{
level.defaultPlayer->camera.MoveCamera(-level.moveSpeed);
}
} }
} }
} }
////////// DrawGLScene(level);
//Move forward
if(!level.defaultPlayer->controls.forward.IsEmpty())
{
level.defaultPlayer->controls.forward.FirstPosition();
if(keys[level.defaultPlayer->controls.forward.Retrieve()])
{
level.defaultPlayer->camera.MoveCamera(level.moveSpeed);
}
else
{
while(level.defaultPlayer->controls.forward.NextPosition() && (keys[level.defaultPlayer->controls.forward.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.forward.Retrieve()])
{
level.defaultPlayer->camera.MoveCamera(level.moveSpeed);
}
}
}
}
//////////
//Strafe Left
if(!level.defaultPlayer->controls.moveLeft.IsEmpty())
{
level.defaultPlayer->controls.moveLeft.FirstPosition();
if(keys[level.defaultPlayer->controls.moveLeft.Retrieve()])
{
level.defaultPlayer->camera.StrafeCamera(-level.moveSpeed);
}
else
{
while(level.defaultPlayer->controls.moveLeft.NextPosition() && (keys[level.defaultPlayer->controls.moveLeft.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.moveLeft.Retrieve()])
{
level.defaultPlayer->camera.StrafeCamera(-level.moveSpeed);
}
}
}
}
//////////
//Strafe Right
if(!level.defaultPlayer->controls.moveRight.IsEmpty())
{
level.defaultPlayer->controls.moveRight.FirstPosition();
if(keys[level.defaultPlayer->controls.moveRight.Retrieve()])
{
level.defaultPlayer[0].camera.StrafeCamera(level.moveSpeed);
}
else
{
while(level.defaultPlayer->controls.moveRight.NextPosition() && (keys[level.defaultPlayer->controls.moveRight.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.moveRight.Retrieve()])
{
level.defaultPlayer->camera.StrafeCamera(level.moveSpeed);
}
}
}
}
//////////
//Keyboard Look Left
if(!level.defaultPlayer->controls.lookLeft.IsEmpty())
{
level.defaultPlayer->controls.lookLeft.FirstPosition();
if(keys[level.defaultPlayer->controls.lookLeft.Retrieve()])
{
level.defaultPlayer[0].camera.RotateView(level.turnSpeed, 0, 1, 0);
}
else
{
while(level.defaultPlayer->controls.lookLeft.NextPosition() && (keys[level.defaultPlayer->controls.lookLeft.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.lookLeft.Retrieve()])
{
level.defaultPlayer[0].camera.RotateView(level.turnSpeed, 0, 1, 0);
}
}
}
}
//////////
//Keyboard Look Right
if(!level.defaultPlayer->controls.lookRight.IsEmpty())
{
level.defaultPlayer->controls.lookRight.FirstPosition();
if(keys[level.defaultPlayer->controls.lookRight.Retrieve()])
{
level.defaultPlayer->camera.RotateView(-level.turnSpeed, 0, 1, 0);
}
else
{
while(level.defaultPlayer->controls.lookRight.NextPosition() && (keys[level.defaultPlayer->controls.lookRight.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.lookRight.Retrieve()])
{
level.defaultPlayer->camera.RotateView(-level.turnSpeed, 0, 1, 0);
}
}
}
}
//////////
//Keyboard Look Up
if(!level.defaultPlayer->controls.lookUp.IsEmpty())
{
level.defaultPlayer->controls.lookUp.FirstPosition();
if(keys[level.defaultPlayer->controls.lookUp.Retrieve()])
{
level.defaultPlayer->camera.RotateView(level.turnSpeed, 1, 0, 0);
}
else
{
while(level.defaultPlayer->controls.lookUp.NextPosition() && (keys[level.defaultPlayer->controls.lookUp.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.lookUp.Retrieve()])
{
level.defaultPlayer->camera.RotateView(level.turnSpeed, 1, 0, 0);
}
}
}
}
//////////
//Keyboard Look Down
if(!level.defaultPlayer->controls.lookDown.IsEmpty())
{
level.defaultPlayer->controls.lookDown.FirstPosition();
if(keys[level.defaultPlayer->controls.lookDown.Retrieve()])
{
level.defaultPlayer->camera.RotateView(-level.turnSpeed, 1, 0, 0);
}
else
{
while(level.defaultPlayer->controls.lookDown.NextPosition() && (keys[level.defaultPlayer->controls.lookDown.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.lookDown.Retrieve()])
{
level.defaultPlayer->camera.RotateView(-level.turnSpeed, 1, 0, 0);
}
}
}
}
//////////
//Toggle Show FPS
if(!level.defaultPlayer->controls.toggleFPS.IsEmpty())
{
level.defaultPlayer->controls.toggleFPS.FirstPosition();
if(keys[level.defaultPlayer->controls.toggleFPS.Retrieve()])
{
if(!keys2[level.defaultPlayer->controls.toggleFPS.Retrieve()])
{
level.showFPS = !level.showFPS;
}
}
else
{
while(level.defaultPlayer->controls.toggleFPS.NextPosition() && (keys[level.defaultPlayer->controls.toggleFPS.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.toggleFPS.Retrieve()])
{
if(!keys2[level.defaultPlayer->controls.toggleFPS.Retrieve()])
{
level.showFPS = !level.showFPS;
}
}
}
}
}
//////////
//Toggle MouseLook
if(!level.defaultPlayer->controls.toggleMouseLook.IsEmpty())
{
level.defaultPlayer->controls.toggleMouseLook.FirstPosition();
if(keys[level.defaultPlayer->controls.toggleMouseLook.Retrieve()])
{
if(keys2[level.defaultPlayer->controls.toggleMouseLook.Retrieve()])
{
level.mlook = ! level.mlook;
}
}
else
{
while(level.defaultPlayer->controls.toggleMouseLook.NextPosition() && (keys[level.defaultPlayer->controls.toggleMouseLook.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.toggleMouseLook.Retrieve()])
{
if(keys2[level.defaultPlayer->controls.toggleMouseLook.Retrieve()])
{
level.mlook = ! level.mlook;
}
}
}
}
}
//////////
//Toggle Console
if(!level.defaultPlayer[0].controls.toggleConsole.IsEmpty())
{
level.defaultPlayer[0].controls.toggleConsole.FirstPosition();
if(keys[level.defaultPlayer[0].controls.toggleConsole.Retrieve()])
{
if(!keys2[level.defaultPlayer[0].controls.toggleConsole.Retrieve()])
{
level.showConsole = !level.showConsole;
keys2[level.defaultPlayer[0].controls.toggleConsole.Retrieve()] = true;
}
}
else
{
while(level.defaultPlayer[0].controls.toggleConsole.NextPosition() && (keys[level.defaultPlayer[0].controls.toggleConsole.Retrieve()] != true));
{
if(keys[level.defaultPlayer[0].controls.toggleConsole.Retrieve()])
{
if(!keys2[level.defaultPlayer[0].controls.toggleConsole.Retrieve()])
{
level.showConsole = !level.showConsole;
keys2[level.defaultPlayer[0].controls.toggleConsole.Retrieve()] = true;
}
}
}
}
}
//////////
//Quick MouseLook
if(!level.defaultPlayer->controls.quickMouseLook.IsEmpty())
{
level.defaultPlayer->controls.quickMouseLook.FirstPosition();
if(keys[level.defaultPlayer->controls.quickMouseLook.Retrieve()])
{
if(keys2[level.defaultPlayer->controls.quickMouseLook.Retrieve()])
{
level.mlook = ! level.mlook;
}
}
else
{
while(level.defaultPlayer->controls.quickMouseLook.NextPosition() && (keys[level.defaultPlayer->controls.quickMouseLook.Retrieve()] != true));
{
if(keys[level.defaultPlayer->controls.quickMouseLook.Retrieve()])
{
if(keys2[level.defaultPlayer->controls.quickMouseLook.Retrieve()])
{
level.mlook = ! level.mlook;
}
}
}
}
}
}
}
}
DrawGLScene();
if(keys[OpenArena::KEY_F1]) if(keys[OpenArena::KEY_F1])
{ {
keys[OpenArena::KEY_F1] = false; keys[OpenArena::KEY_F1] = false;
g_Screen.Close(); g_Screen->Close();
g_Screen.ToggleFullscreen(); g_Screen->ToggleFullscreen();
if(!g_Screen.Open(OPENARENA_VERSION, level.screen.GetWidth(), level.screen.GetHeight(), level.screen.GetColorDepth(), level.screen.GetFullscreen())) if(!g_Screen->Open(OPENARENA_VERSION, level->screen.GetWidth(), level->screen.GetHeight(), level->screen.GetColorDepth(), level->screen.GetFullscreen()))
{ {
return 1; return 1;
} }
} }
} }
level.UnloadMap(); level->UnloadMap();
g_Screen.Close(); g_Screen->Close();
exit(0); exit(0);
} }
//This should probably be moved into oa_input
unsigned char TranslateKey(int keyCode)
{
switch (keyCode)
{
case XK_BackSpace:
return OpenArena::KEY_BACK;
case XK_Tab:
return OpenArena::KEY_TAB;
case XK_Return:
return OpenArena::KEY_RETURN;
case XK_Escape:
return OpenArena::KEY_ESCAPE;
case XK_Left:
return OpenArena::KEY_LEFT;
case XK_Right:
return OpenArena::KEY_RIGHT;
case XK_Up:
return OpenArena::KEY_UP;
case XK_Down:
return OpenArena::KEY_DOWN;
case XK_Home:
return OpenArena::KEY_HOME;
case XK_End:
return OpenArena::KEY_END;
case XK_Prior:
return OpenArena::KEY_PRIOR;
case XK_Next:
return OpenArena::KEY_NEXT;
case XK_Num_Lock:
return OpenArena::KEY_NUMLOCK;
case XK_KP_Enter:
return OpenArena::KEY_RETURN;
case XK_KP_Home:
return OpenArena::KEY_HOME;
case XK_KP_End:
return OpenArena::KEY_END;
case XK_KP_Prior:
return OpenArena::KEY_PRIOR;
case XK_KP_Next:
return OpenArena::KEY_NEXT;
case XK_KP_0:
return OpenArena::KEY_NUMPAD0;
case XK_KP_1:
return OpenArena::KEY_NUMPAD1;
case XK_KP_2:
return OpenArena::KEY_NUMPAD2;
case XK_KP_3:
return OpenArena::KEY_NUMPAD3;
case XK_KP_4:
return OpenArena::KEY_NUMPAD4;
case XK_KP_5:
return OpenArena::KEY_NUMPAD5;
case XK_KP_6:
return OpenArena::KEY_NUMPAD6;
case XK_KP_7:
return OpenArena::KEY_NUMPAD7;
case XK_KP_8:
return OpenArena::KEY_NUMPAD8;
case XK_KP_9:
return OpenArena::KEY_NUMPAD9;
case XK_KP_Multiply:
return OpenArena::KEY_MULTIPLY;
case XK_KP_Add:
return OpenArena::KEY_ADD;
case XK_KP_Subtract:
return OpenArena::KEY_SUBTRACT;
case XK_KP_Divide:
return OpenArena::KEY_DIVIDE;
case XK_F1:
return OpenArena::KEY_F1;
case XK_F2:
return OpenArena::KEY_F2;
case XK_F3:
return OpenArena::KEY_F3;
case XK_F4:
return OpenArena::KEY_F4;
case XK_F5:
return OpenArena::KEY_F5;
case XK_F6:
return OpenArena::KEY_F6;
case XK_F7:
return OpenArena::KEY_F7;
case XK_F8:
return OpenArena::KEY_F8;
case XK_F9:
return OpenArena::KEY_F9;
case XK_F10:
return OpenArena::KEY_F10;
case XK_F11:
return OpenArena::KEY_F11;
case XK_F12:
return OpenArena::KEY_F12;
case XK_Shift_L:
return OpenArena::KEY_SHIFT;
case XK_Shift_R:
return OpenArena::KEY_SHIFT;
case XK_Control_L:
return OpenArena::KEY_CONTROL;
case XK_Control_R:
return OpenArena::KEY_CONTROL;
case XK_Caps_Lock:
return OpenArena::KEY_CAPITAL;
case XK_Pause:
return OpenArena::KEY_PAUSE;
case XK_KP_Space:
case XK_space:
return OpenArena::KEY_SPACE;
case XK_Insert:
return OpenArena::KEY_INSERT;
case XK_Delete:
return OpenArena::KEY_DELETE;
case XK_KP_Separator:
return OpenArena::KEY_SEPARATOR;
case XK_Scroll_Lock:
return OpenArena::KEY_SCROLL;
case XK_period:
return OpenArena::KEY_OEM_PERIOD;
case XK_plus:
return OpenArena::KEY_OEM_PLUS;
case XK_minus:
return OpenArena::KEY_OEM_MINUS;
case XK_comma:
return OpenArena::KEY_OEM_COMMA;
case XK_0:
return OpenArena::KEY_0;
case XK_1:
return OpenArena::KEY_1;
case XK_2:
return OpenArena::KEY_2;
case XK_3:
return OpenArena::KEY_3;
case XK_4:
return OpenArena::KEY_4;
case XK_5:
return OpenArena::KEY_5;
case XK_6:
return OpenArena::KEY_6;
case XK_7:
return OpenArena::KEY_7;
case XK_8:
return OpenArena::KEY_8;
case XK_9:
return OpenArena::KEY_9;
case XK_a:
case XK_A:
return OpenArena::KEY_A;
case XK_b:
case XK_B:
return OpenArena::KEY_B;
case XK_c:
case XK_C:
return OpenArena::KEY_C;
case XK_d:
case XK_D:
return OpenArena::KEY_D;
case XK_e:
case XK_E:
return OpenArena::KEY_E;
case XK_f:
case XK_F:
return OpenArena::KEY_F;
case XK_g:
case XK_G:
return OpenArena::KEY_G;
case XK_h:
case XK_H:
return OpenArena::KEY_H;
case XK_i:
case XK_I:
return OpenArena::KEY_I;
case XK_j:
case XK_J:
return OpenArena::KEY_J;
case XK_k:
case XK_K:
return OpenArena::KEY_K;
case XK_l:
case XK_L:
return OpenArena::KEY_L;
case XK_m:
case XK_M:
return OpenArena::KEY_M;
case XK_n:
case XK_N:
return OpenArena::KEY_N;
case XK_o:
case XK_O:
return OpenArena::KEY_O;
case XK_p:
case XK_P:
return OpenArena::KEY_P;
case XK_q:
case XK_Q:
return OpenArena::KEY_Q;
case XK_r:
case XK_R:
return OpenArena::KEY_R;
case XK_s:
case XK_S:
return OpenArena::KEY_S;
case XK_t:
case XK_T:
return OpenArena::KEY_T;
case XK_u:
case XK_U:
return OpenArena::KEY_U;
case XK_v:
case XK_V:
return OpenArena::KEY_V;
case XK_w:
case XK_W:
return OpenArena::KEY_W;
case XK_x:
case XK_X:
return OpenArena::KEY_X;
case XK_y:
case XK_Y:
return OpenArena::KEY_Y;
case XK_z:
case XK_Z:
return OpenArena::KEY_Z;
case XK_grave:
return OpenArena::KEY_OEM_3;
case XK_Super_L:
return OpenArena::KEY_LWIN;
case XK_Super_R:
return OpenArena::KEY_RWIN;
case XK_Menu:
return OpenArena::KEY_APPS;
case XK_bracketleft:
return OpenArena::KEY_OEM_4;
case XK_bracketright:
return OpenArena::KEY_OEM_6;
case XK_backslash:
return OpenArena::KEY_OEM_5;
case XK_semicolon:
return OpenArena::KEY_OEM_1;
case XK_apostrophe:
return OpenArena::KEY_OEM_7;
case XK_slash:
return OpenArena::KEY_OEM_2;
case XK_Alt_L:
return OpenArena::KEY_UNKNOWN;
case XK_Alt_R:
return OpenArena::KEY_UNKNOWN;
/*These keys definately still need to be accounted for
` 96
pause 65299
win 65515
apps 65383
- 45
= 61
[ 91
] 93
\ 92
; 59
' 39
' 47
left alt 65513
right alt 65514
#define KEY_LBUTTON 1
#define KEY_RBUTTON 2
#define KEY_MBUTTON 3
#define KEY_LWIN 21
#define KEY_RWIN 22
#define KEY_APPS 23
#define KEY_OEM_1 53
#define KEY_OEM_2 54
#define KEY_OEM_3 55
#define KEY_OEM_4 56
#define KEY_OEM_5 57
#define KEY_OEM_6 58
#define KEY_OEM_7 59
*/
default:
return OpenArena::KEY_UNKNOWN;
}
}
unsigned char TranslateButton(int keyCode)
{
switch(keyCode)
{
case Button1:
return OpenArena::KEY_BUTTON0;
case Button2:
return OpenArena::KEY_BUTTON2;
case Button3:
return OpenArena::KEY_BUTTON1;
case Button4:
return OpenArena::KEY_BUTTON3;
case Button5:
return OpenArena::KEY_BUTTON4;
}
}
void HandleConsoleKeyPress(OpenArena::Keys key)
{
//See if we need to hide the console
level.defaultPlayer[0].controls.toggleConsole.FirstPosition();
if(key == level.defaultPlayer[0].controls.toggleConsole.Retrieve())
{
level.showConsole = false;
}
else
{
while(level.defaultPlayer[0].controls.toggleConsole.NextPosition() && level.showConsole)
{
if(level.defaultPlayer[0].controls.toggleConsole.Retrieve() == key)
{
level.showConsole = false;
}
}
}
switch (key)
{
case OpenArena::KEY_SHIFT:
keys[OpenArena::KEY_SHIFT] = true;
break;
case OpenArena::KEY_RETURN:
level.UpdateConsole('\n');
break;
case OpenArena::KEY_SPACE:
printf("hello");
level.UpdateConsole(' ');
break;
case OpenArena::KEY_BACK:
level.UpdateConsole(OpenArena::KEY_BACK);
break;
default:
char ascii = OpenArena::KeyToASCII(key, keys[OpenArena::KEY_SHIFT]);
if(ascii != '\0')
{
level.UpdateConsole(ascii);
}
}
}
bool keys[256]; bool keys[256];
bool keys2[256]; bool keys2[256];
bool active; bool active;

2
src/player.h
View File

@@ -41,7 +41,7 @@ namespace OpenArena
ControlScheme controls; ControlScheme controls;
Camera camera; Camera camera;
EventManager eventManager; EventManager* eventManager;
class EventHandler class EventHandler
{ {