811 lines
27 KiB
C++
Executable File
811 lines
27 KiB
C++
Executable File
/***************************************************************************
|
|
* Copyright (C) 2001-2023 by Tom Hicks *
|
|
* headhunter3@gmail.com *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
|
|
***************************************************************************/
|
|
|
|
#ifdef _WIN32
|
|
// clang-format off
|
|
// include necessary header files
|
|
#include "windows.h"
|
|
#include <iostream>
|
|
#include "DrawEvent.h"
|
|
#include "EventManager.h"
|
|
#include "KeyPressEvent.h"
|
|
#include "KeyReleaseEvent.h"
|
|
#include "Logger.h"
|
|
#include "WindowsLogger.h"
|
|
#include "console_logger.h"
|
|
#include "level.h"
|
|
#include "main.h"
|
|
#include "mygl.h"
|
|
#include "opengl.h"
|
|
#include "opengl/window.h"
|
|
#include "vector.h"
|
|
#include "version.h"
|
|
|
|
// clang-format on
|
|
|
|
namespace {
|
|
using OpenArena::ConsoleLogger;
|
|
using OpenArena::ControlScheme;
|
|
using OpenArena::DrawEvent;
|
|
using OpenArena::EventManager;
|
|
using OpenArena::g_Screen;
|
|
using OpenArena::KeyPressEvent;
|
|
using OpenArena::KeyReleaseEvent;
|
|
using OpenArena::Keys;
|
|
using OpenArena::Level;
|
|
using OpenArena::Logger;
|
|
using OpenArena::Vec2i;
|
|
using OpenArena::WindowsLogger;
|
|
using OpenArena::OpenGL::Window;
|
|
using std::exception;
|
|
using std::make_shared;
|
|
using std::string;
|
|
using std::to_string;
|
|
} // End namespace
|
|
|
|
void InitControls();
|
|
int InitGL(GLvoid);
|
|
void ReSizeGLScene(GLsizei width, GLsizei height);
|
|
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow);
|
|
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
Keys TranslateKey(int keyCode);
|
|
void HandleConsoleKeyPress(Keys key);
|
|
|
|
Level* level = nullptr;
|
|
bool keys[256] = {false};
|
|
bool keys2[256] = {false};
|
|
bool active = false;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function Definitions
|
|
|
|
int DrawGLScene(Level* level) {
|
|
level->Render();
|
|
|
|
g_Screen->SwapBuffers();
|
|
|
|
return 1;
|
|
}
|
|
|
|
//
|
|
// void InitControls()
|
|
// Purpose:
|
|
// Initializes controls by loading the default control config file "my.cfg".
|
|
|
|
void InitControls() {
|
|
if (!level->LoadConfig("my.cfg")) {
|
|
level->LoadConfig();
|
|
};
|
|
}
|
|
|
|
//
|
|
// int InitGL(GLvoid)
|
|
// Purpose:
|
|
// To do all required setup before creating an OpenGL window
|
|
// Pre:
|
|
//
|
|
// Post:
|
|
//
|
|
|
|
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;
|
|
}
|
|
|
|
//
|
|
// GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
|
|
// Purpose:
|
|
// To resize the OpenGL window also called on creation
|
|
// Pre:
|
|
//
|
|
// Post:
|
|
//
|
|
|
|
void ReSizeGLScene(GLsizei width, GLsizei height) {
|
|
if (height == 0) height = 1;
|
|
glViewport(0, 0, width, height);
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
|
|
gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 100.0f);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
}
|
|
|
|
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
switch (uMsg) {
|
|
case WM_ACTIVATE: {
|
|
if (!HIWORD(wParam)) {
|
|
active = true;
|
|
} else {
|
|
active = false;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
case WM_SYSCOMMAND: {
|
|
switch (wParam) {
|
|
case SC_SCREENSAVE:
|
|
case SC_MONITORPOWER:
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
case WM_CLOSE: {
|
|
PostQuitMessage(0);
|
|
return 0;
|
|
}
|
|
case WM_KEYDOWN: {
|
|
if (level->showConsole) {
|
|
HandleConsoleKeyPress((Keys)TranslateKey(wParam));
|
|
} else {
|
|
keys[TranslateKey(wParam)] = true;
|
|
}
|
|
return 0;
|
|
}
|
|
case WM_KEYUP: {
|
|
keys[TranslateKey(wParam)] = false;
|
|
keys2[TranslateKey(wParam)] = false;
|
|
return 0;
|
|
}
|
|
case WM_SYSKEYDOWN:
|
|
break;
|
|
case WM_SIZE: {
|
|
ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
|
|
return 0;
|
|
}
|
|
case WM_LBUTTONDOWN: {
|
|
keys[OpenArena::KEY_LBUTTON] = true;
|
|
return 0;
|
|
}
|
|
case WM_LBUTTONUP: {
|
|
keys[OpenArena::KEY_LBUTTON] = false;
|
|
keys[OpenArena::KEY_LBUTTON] = false;
|
|
return 0;
|
|
}
|
|
case WM_RBUTTONDOWN: {
|
|
keys[OpenArena::KEY_RBUTTON] = true;
|
|
return 0;
|
|
}
|
|
case WM_RBUTTONUP: {
|
|
keys[OpenArena::KEY_RBUTTON] = false;
|
|
keys[OpenArena::KEY_RBUTTON] = false;
|
|
return 0;
|
|
}
|
|
case WM_MBUTTONDOWN: {
|
|
keys[OpenArena::KEY_MBUTTON] = true;
|
|
return 0;
|
|
}
|
|
case WM_MBUTTONUP: {
|
|
keys[OpenArena::KEY_MBUTTON] = false;
|
|
keys[OpenArena::KEY_MBUTTON] = false;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return DefWindowProc(hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
|
|
auto p_console_logger = make_shared<ConsoleLogger>();
|
|
auto p_windows_logger = make_shared<WindowsLogger>();
|
|
p_windows_logger->SetMinType(Logger::MessageType::Error);
|
|
Logger::AddLogger(p_console_logger);
|
|
Logger::AddLogger(p_windows_logger);
|
|
Logger::LogDebug("Starting");
|
|
OpenArena::Logger::LogUnimplementedMethod;
|
|
MSG msg;
|
|
try {
|
|
g_Screen = new Window();
|
|
DrawEvent::DrawEventHandler* _drawEventHandler = new DrawEvent::DrawEventHandler(level);
|
|
KeyPressEvent::KeyPressEventHandler* _keyPressEventHandler = new KeyPressEvent::KeyPressEventHandler();
|
|
KeyReleaseEvent::KeyReleaseEventHandler* _keyReleaseEventHandler = new KeyReleaseEvent::KeyReleaseEventHandler();
|
|
|
|
EventManager* em = new EventManager();
|
|
level = new Level(em);
|
|
bool done = false;
|
|
if (strlen(lpCmdLine)) level->ParseCmds(lpCmdLine);
|
|
InitControls();
|
|
g_Screen->SetInitializer(new Window::Initializer());
|
|
g_Screen->SetResizer(new Window::Resizer());
|
|
if (!g_Screen->Open(string(OPENARENA_VERSION), g_Screen->GetWidth(), g_Screen->GetHeight(),
|
|
g_Screen->GetColorDepth(), g_Screen->GetFullscreen())) {
|
|
Logger::LogError("Screen open failed.");
|
|
return -1;
|
|
}
|
|
|
|
level->SetWindow(g_Screen);
|
|
level->glFont.SetScreenDimensions(g_Screen->GetWidth() * 2, g_Screen->GetHeight() * 2);
|
|
|
|
if (level->nextLevel == "") {
|
|
Logger::LogDebug("Loading intro.map");
|
|
level->LoadMap("intro.map");
|
|
} else {
|
|
Logger::LogDebug("Loading nextLevel: " + level->nextLevel);
|
|
level->LoadMap();
|
|
}
|
|
Logger::LogDebug("About to start main loop.");
|
|
while (!done) {
|
|
// Logger::LogDebug("in while(!done)");
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
|
if (msg.message == WM_QUIT) {
|
|
done = true;
|
|
} else {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
|
|
if (active) {
|
|
if (keys[OpenArena::KEY_ESCAPE]) {
|
|
done = true;
|
|
} else {
|
|
level->defaultPlayer[0].camera.Update();
|
|
|
|
if (!level->showConsole) {
|
|
if (level->mlook) {
|
|
Vec2i middleOfScreen = Vec2i(g_Screen->GetWidth() / 2, g_Screen->GetHeight() / 2);
|
|
Vec2i mousePosition = g_Screen->GetMousePosition();
|
|
if (mousePosition != middleOfScreen) {
|
|
// Vec2i mouseDelta = mousePosition - middleOfScreen;
|
|
Vec2i mouseDelta = middleOfScreen - mousePosition;
|
|
g_Screen->SetMousePosition(middleOfScreen);
|
|
const float MOUSE_SENSITIVITY_HORIZONTAL = 0.005f;
|
|
const float MOUSE_SENSITIVITY_VERTICAL = 0.005f;
|
|
float horizontalAngle = mouseDelta.x * MOUSE_SENSITIVITY_HORIZONTAL;
|
|
float verticalAngle = mouseDelta.y * MOUSE_SENSITIVITY_VERTICAL;
|
|
level->defaultPlayer[0].camera.RotateHorizontal(horizontalAngle);
|
|
level->defaultPlayer[0].camera.RotateVertical(verticalAngle);
|
|
}
|
|
} else {
|
|
g_Screen->SetMousePosition(Vec2i(g_Screen->GetWidth() / 2, g_Screen->GetHeight() / 2));
|
|
}
|
|
|
|
// //////////
|
|
// // 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);
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// //////////
|
|
// // 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;
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// level->Render();
|
|
}
|
|
level->Render();
|
|
//
|
|
}
|
|
}
|
|
|
|
// Why the hell are we swapping buffers even if the window is not active?
|
|
g_Screen->SwapBuffers();
|
|
|
|
if (keys[Keys::KEY_F1]) {
|
|
keys[Keys::KEY_F1] = false;
|
|
g_Screen->Close();
|
|
g_Screen->ToggleFullscreen();
|
|
if (!g_Screen->Open("OpenArena", g_Screen->GetWidth(), g_Screen->GetHeight(), g_Screen->GetColorDepth(),
|
|
g_Screen->GetFullscreen())) {
|
|
Logger::LogError("Window failed to reopen after changing fullscreen flag.");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
} catch (const exception& ex) {
|
|
Logger::LogWtf("Unhandled exception", ex);
|
|
} catch (...) {
|
|
Logger::LogWtf("Unhandled exception");
|
|
}
|
|
|
|
Logger::LogDebug("level->UnloadMap()");
|
|
level->UnloadMap();
|
|
g_Screen->Close();
|
|
Logger::LogDebug("g_Screen->Close()");
|
|
Logger::LogDebug("Exiting with msg.wParam " + to_string(msg.wParam));
|
|
return (msg.wParam);
|
|
}
|
|
|
|
Keys TranslateKey(int keyCode) {
|
|
switch (keyCode) {
|
|
case VK_LEFT:
|
|
return OpenArena::KEY_LEFT;
|
|
case VK_RIGHT:
|
|
return OpenArena::KEY_RIGHT;
|
|
case VK_UP:
|
|
return OpenArena::KEY_UP;
|
|
case VK_DOWN:
|
|
return OpenArena::KEY_DOWN;
|
|
case VK_SPACE:
|
|
return OpenArena::KEY_SPACE;
|
|
case VK_RETURN:
|
|
return OpenArena::KEY_RETURN;
|
|
case VK_SHIFT:
|
|
return OpenArena::KEY_SHIFT;
|
|
case VK_PAUSE:
|
|
return OpenArena::KEY_PAUSE;
|
|
case VK_CONTROL:
|
|
return OpenArena::KEY_CONTROL;
|
|
case VK_CAPITAL:
|
|
return OpenArena::KEY_CAPITAL;
|
|
case VK_ESCAPE:
|
|
return OpenArena::KEY_ESCAPE;
|
|
case VK_PRIOR:
|
|
return OpenArena::KEY_PRIOR;
|
|
case VK_NEXT:
|
|
return OpenArena::KEY_NEXT;
|
|
case VK_END:
|
|
return OpenArena::KEY_END;
|
|
case VK_HOME:
|
|
return OpenArena::KEY_HOME;
|
|
case VK_INSERT:
|
|
return OpenArena::KEY_INSERT;
|
|
case VK_DELETE:
|
|
return OpenArena::KEY_DELETE;
|
|
case VK_LWIN:
|
|
return OpenArena::KEY_LWIN;
|
|
case VK_RWIN:
|
|
return OpenArena::KEY_RWIN;
|
|
case VK_APPS:
|
|
return OpenArena::KEY_APPS;
|
|
case VK_NUMPAD0:
|
|
return OpenArena::KEY_NUMPAD0;
|
|
case VK_NUMPAD1:
|
|
return OpenArena::KEY_NUMPAD1;
|
|
case VK_NUMPAD2:
|
|
return OpenArena::KEY_NUMPAD2;
|
|
case VK_NUMPAD3:
|
|
return OpenArena::KEY_NUMPAD3;
|
|
case VK_NUMPAD4:
|
|
return OpenArena::KEY_NUMPAD4;
|
|
case VK_NUMPAD5:
|
|
return OpenArena::KEY_NUMPAD5;
|
|
case VK_NUMPAD6:
|
|
return OpenArena::KEY_NUMPAD6;
|
|
case VK_NUMPAD7:
|
|
return OpenArena::KEY_NUMPAD7;
|
|
case VK_NUMPAD8:
|
|
return OpenArena::KEY_NUMPAD8;
|
|
case VK_NUMPAD9:
|
|
return OpenArena::KEY_NUMPAD9;
|
|
case VK_MULTIPLY:
|
|
return OpenArena::KEY_MULTIPLY;
|
|
case VK_ADD:
|
|
return OpenArena::KEY_ADD;
|
|
case VK_SUBTRACT:
|
|
return OpenArena::KEY_SUBTRACT;
|
|
case VK_DIVIDE:
|
|
return OpenArena::KEY_DIVIDE;
|
|
case VK_F1:
|
|
return OpenArena::KEY_F1;
|
|
case VK_F2:
|
|
return OpenArena::KEY_F2;
|
|
case VK_F3:
|
|
return OpenArena::KEY_F3;
|
|
case VK_F4:
|
|
return OpenArena::KEY_F4;
|
|
case VK_F5:
|
|
return OpenArena::KEY_F5;
|
|
case VK_F6:
|
|
return OpenArena::KEY_F6;
|
|
case VK_F7:
|
|
return OpenArena::KEY_F7;
|
|
case VK_F8:
|
|
return OpenArena::KEY_F8;
|
|
case VK_F9:
|
|
return OpenArena::KEY_F9;
|
|
case VK_F10:
|
|
return OpenArena::KEY_F10;
|
|
case VK_F11:
|
|
return OpenArena::KEY_F11;
|
|
case VK_F12:
|
|
return OpenArena::KEY_F12;
|
|
case VK_NUMLOCK:
|
|
return OpenArena::KEY_NUMLOCK;
|
|
case VK_SCROLL:
|
|
return OpenArena::KEY_SCROLL;
|
|
case VK_SEPARATOR:
|
|
return OpenArena::KEY_SEPARATOR;
|
|
case VK_OEM_1:
|
|
return OpenArena::KEY_OEM_1;
|
|
case VK_OEM_2:
|
|
return OpenArena::KEY_OEM_2;
|
|
case VK_OEM_3:
|
|
return OpenArena::KEY_OEM_3;
|
|
case VK_OEM_4:
|
|
return OpenArena::KEY_OEM_4;
|
|
case VK_OEM_5:
|
|
return OpenArena::KEY_OEM_5;
|
|
case VK_OEM_6:
|
|
return OpenArena::KEY_OEM_6;
|
|
case VK_OEM_7:
|
|
return OpenArena::KEY_OEM_7;
|
|
case VK_OEM_PERIOD:
|
|
return OpenArena::KEY_OEM_PERIOD;
|
|
case VK_OEM_PLUS:
|
|
return OpenArena::KEY_OEM_PLUS;
|
|
case VK_OEM_MINUS:
|
|
return OpenArena::KEY_OEM_MINUS;
|
|
case VK_OEM_COMMA:
|
|
return OpenArena::KEY_OEM_COMMA;
|
|
case VK_BACK:
|
|
return OpenArena::KEY_BACK;
|
|
case VK_TAB:
|
|
return OpenArena::KEY_TAB;
|
|
case '0':
|
|
return OpenArena::KEY_0;
|
|
case '1':
|
|
return OpenArena::KEY_1;
|
|
case '2':
|
|
return OpenArena::KEY_2;
|
|
case '3':
|
|
return OpenArena::KEY_3;
|
|
case '4':
|
|
return OpenArena::KEY_4;
|
|
case '5':
|
|
return OpenArena::KEY_5;
|
|
case '6':
|
|
return OpenArena::KEY_6;
|
|
case '7':
|
|
return OpenArena::KEY_7;
|
|
case '8':
|
|
return OpenArena::KEY_8;
|
|
case '9':
|
|
return OpenArena::KEY_9;
|
|
case 'A':
|
|
return OpenArena::KEY_A;
|
|
case 'B':
|
|
return OpenArena::KEY_B;
|
|
case 'C':
|
|
return OpenArena::KEY_C;
|
|
case 'D':
|
|
return OpenArena::KEY_D;
|
|
case 'E':
|
|
return OpenArena::KEY_E;
|
|
case 'F':
|
|
return OpenArena::KEY_F;
|
|
case 'G':
|
|
return OpenArena::KEY_G;
|
|
case 'H':
|
|
return OpenArena::KEY_H;
|
|
case 'I':
|
|
return OpenArena::KEY_I;
|
|
case 'J':
|
|
return OpenArena::KEY_J;
|
|
case 'K':
|
|
return OpenArena::KEY_K;
|
|
case 'L':
|
|
return OpenArena::KEY_L;
|
|
case 'M':
|
|
return OpenArena::KEY_M;
|
|
case 'N':
|
|
return OpenArena::KEY_N;
|
|
case 'O':
|
|
return OpenArena::KEY_O;
|
|
case 'P':
|
|
return OpenArena::KEY_P;
|
|
case 'Q':
|
|
return OpenArena::KEY_Q;
|
|
case 'R':
|
|
return OpenArena::KEY_R;
|
|
case 'S':
|
|
return OpenArena::KEY_S;
|
|
case 'T':
|
|
return OpenArena::KEY_T;
|
|
case 'U':
|
|
return OpenArena::KEY_U;
|
|
case 'V':
|
|
return OpenArena::KEY_V;
|
|
case 'W':
|
|
return OpenArena::KEY_W;
|
|
case 'X':
|
|
return OpenArena::KEY_X;
|
|
case 'Y':
|
|
return OpenArena::KEY_Y;
|
|
case 'Z':
|
|
return OpenArena::KEY_Z;
|
|
case VK_LBUTTON:
|
|
return OpenArena::KEY_LBUTTON;
|
|
case VK_RBUTTON:
|
|
return OpenArena::KEY_RBUTTON;
|
|
case VK_MBUTTON:
|
|
return OpenArena::KEY_MBUTTON;
|
|
default:
|
|
return OpenArena::KEY_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
void HandleConsoleKeyPress(Keys key) {
|
|
// See if we need to hide the console
|
|
if (level->defaultPlayer->controls.GetAction(key) == ControlScheme::ACTION_TOGGLE_CONSOLE) {
|
|
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 = KeyToASCII(key, keys[OpenArena::KEY_SHIFT]);
|
|
if (ascii != '\0') {
|
|
level->UpdateConsole(ascii);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|