633 lines
19 KiB
C++
633 lines
19 KiB
C++
/************************************************************************
|
|
* Copyright (c) 2005-2006 tok@openlinux.org.uk *
|
|
* *
|
|
* This software is provided as-is, without any express or implied *
|
|
* warranty. In no event will the authors be held liable for any *
|
|
* damages arising from the use of this software. *
|
|
* *
|
|
* Permission is granted to anyone to use this software for any purpose, *
|
|
* including commercial applications, and to alter it and redistribute *
|
|
* it freely, subject to the following restrictions: *
|
|
* *
|
|
* 1. The origin of this software must not be misrepresented; you must *
|
|
* not claim that you wrote the original software. If you use this *
|
|
* software in a product, an acknowledgment in the product documentation *
|
|
* would be appreciated but is not required. *
|
|
* *
|
|
* 2. Altered source versions must be plainly marked as such, and must *
|
|
* not be misrepresented as being the original software. *
|
|
* *
|
|
* 3. This notice may not be removed or altered from any source *
|
|
* distribution. *
|
|
************************************************************************/
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <SDL_opengl.h>
|
|
#include <unistd.h>
|
|
//#include "common_sdl_gl.h"
|
|
#include "gl_screen.h"
|
|
#include "opengta.h"
|
|
#include "gl_texturecache.h"
|
|
#include "gl_cityview.h"
|
|
#include "gl_font.h"
|
|
#include "gl_camera.h"
|
|
#include "navdata.h"
|
|
#include "log.h"
|
|
#include "spritemanager.h"
|
|
#include "localplayer.h"
|
|
#include "m_exceptions.h"
|
|
#include "file_helper.h"
|
|
#include "gl_spritecache.h"
|
|
#ifdef WITH_LUA
|
|
#include "lua_addon/lua_vm.h"
|
|
#endif
|
|
|
|
extern SDL_Surface* screen;
|
|
extern int global_EC;
|
|
extern int global_Done;
|
|
GLfloat mapPos[3] = {12.0f, 12.0f, 20.0f};
|
|
|
|
OpenGTA::CityView *city = NULL;
|
|
OpenGL::DrawableFont* m_font = NULL;
|
|
|
|
int city_num = 0;
|
|
const char* styles_8[3] = { "STYLE001.GRY", "STYLE002.GRY", "STYLE003.GRY" };
|
|
const char* styles_24[3] = { "STYLE001.G24", "STYLE002.G24", "STYLE003.G24" };
|
|
const char* cities[3] = { "NYC.CMP", "SANB.CMP", "MIAMI.CMP" };
|
|
std::string specific_map;
|
|
std::string specific_style;
|
|
|
|
Uint32 num_frames_drawn = 0;
|
|
Uint32 fps = 0;
|
|
Uint32 last_tick;
|
|
Uint32 fps_last_tick;
|
|
Uint32 script_last_tick;
|
|
Uint32 arg_screen_w = 0;
|
|
Uint32 arg_screen_h = 0;
|
|
bool rotate = false;
|
|
bool cam_grav = false;
|
|
int tex_flip = 0;
|
|
int draw_arrows = 0;
|
|
int ped_anim = 0;
|
|
int bbox_toggle = 0;
|
|
int texsprite_toggle = 0;
|
|
int follow_toggle = 0;
|
|
OpenGTA::SpriteObject::Animation pedAnim(0, 0);
|
|
bool highcolor_data = false;
|
|
bool full_screen = false;
|
|
bool player_toggle_run = false;
|
|
|
|
const char* script_file = NULL;
|
|
int paused = 0;
|
|
|
|
/*
|
|
void ERROR(const char* s) {
|
|
std::cerr << "Error" << s << std::endl;
|
|
std::cerr << "* last SDL error was: " << SDL_GetError() << std::endl;
|
|
global_EC = 1;
|
|
exit(1);
|
|
}*/
|
|
|
|
void on_exit() {
|
|
SDL_Quit();
|
|
if (city)
|
|
delete city;
|
|
if (m_font)
|
|
delete m_font;
|
|
PHYSFS_deinit();
|
|
if (global_EC)
|
|
std::cerr << "Exiting after fatal problem - please see output above" << std::endl;
|
|
else
|
|
std::cout << "Goodbye" << std::endl;
|
|
}
|
|
|
|
void print_position() {
|
|
Vector3D & v = OpenGL::CameraHolder::Instance().getCenter();
|
|
Vector3D & e = OpenGL::CameraHolder::Instance().getEye();
|
|
Vector3D & u = OpenGL::CameraHolder::Instance().getUp();
|
|
if (!city->getViewMode()) {
|
|
INFO << cities[city_num] << ": " << city->getCurrentSector()->getFullName() << std::endl <<
|
|
"camera.setCenter(" << v.x << ", " << v.y << ", " << v.z << ")" << std::endl <<
|
|
"camera.setEye(" << e.x << ", " << e.y << ", " << e.z << ")" << std::endl <<
|
|
"camera.setUp(" << u.x << ", " << u.y << ", " << u.z << ")" << std::endl <<
|
|
"city_view:setVisibleRange(" << city->getVisibleRange() << ")" << std::endl <<
|
|
"city_view:setTopDownView( false )" << std::endl;
|
|
}
|
|
else {
|
|
GLfloat* cp = city->getCamPos();
|
|
INFO << cities[city_num] << ": " << city->getCurrentSector()->getFullName() << std::endl <<
|
|
"city_view:setCamPosition(" << cp[0] << ", " << cp[1] << ", " << cp[2] << ")" << std::endl <<
|
|
"city_view:setVisibleRange(" << city->getVisibleRange() << ")" << std::endl <<
|
|
"city_view:setTopDownView( true )" << std::endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void handleKeyUp( SDL_keysym *keysym) {
|
|
switch ( keysym->sym ) {
|
|
case 'j':
|
|
OpenGTA::LocalPlayer::Instance().turn = 0;
|
|
break;
|
|
case 'l':
|
|
OpenGTA::LocalPlayer::Instance().turn = 0;
|
|
break;
|
|
case 'i':
|
|
OpenGTA::LocalPlayer::Instance().move = 0;
|
|
break;
|
|
case 'k':
|
|
OpenGTA::LocalPlayer::Instance().move = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void draw_mapmode();
|
|
|
|
void create_ped_at(const Vector3D v) {
|
|
OpenGTA::Pedestrian p(Vector3D(0.3f, 0.5f, 0.3f), v, 0xffffffff);
|
|
p.m_control = &OpenGTA::LocalPlayer::Instance();
|
|
OpenGTA::SpriteManagerHolder::Instance().addPed(p);
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).switchToAnim(1);
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).giveItem(1, 255);
|
|
}
|
|
|
|
void handleKeyPress( SDL_keysym *keysym ) {
|
|
GLfloat* cp = city->getCamPos();
|
|
mapPos[0] = cp[0]; mapPos[1] = cp[1]; mapPos[2] = cp[2];
|
|
OpenGL::Camera & cam = OpenGL::CameraHolder::Instance();
|
|
switch ( keysym->sym ) {
|
|
case SDLK_ESCAPE:
|
|
global_Done = 1;
|
|
break;
|
|
case SDLK_LEFT:
|
|
mapPos[0] -= 1.0f;
|
|
cam.translateBy(Vector3D(-1, 0, 0));
|
|
break;
|
|
case SDLK_RIGHT:
|
|
mapPos[0] += 1.0f;
|
|
cam.translateBy(Vector3D(1, 0, 0));
|
|
break;
|
|
case SDLK_UP:
|
|
mapPos[2] -= 1.0f;
|
|
cam.translateBy(Vector3D(0, 0, -1));
|
|
break;
|
|
case SDLK_DOWN:
|
|
mapPos[2] += 1.0f;
|
|
cam.translateBy(Vector3D(0, 0, 1));
|
|
break;
|
|
case SDLK_SPACE:
|
|
cam.setSpeed(0.0f);
|
|
break;
|
|
case SDLK_F1:
|
|
cam.interpolate(Vector3D(254, 9, 254), 1, 20000);
|
|
break;
|
|
case SDLK_F2:
|
|
bbox_toggle = (bbox_toggle ? 0 : 1);
|
|
OpenGTA::SpriteManagerHolder::Instance().setDrawBBox(bbox_toggle);
|
|
break;
|
|
case SDLK_F3:
|
|
texsprite_toggle = (texsprite_toggle ? 0 : 1);
|
|
OpenGTA::SpriteManagerHolder::Instance().setDrawTexBorder(texsprite_toggle);
|
|
break;
|
|
case SDLK_F4:
|
|
follow_toggle = (follow_toggle ? 0 : 1);
|
|
if (follow_toggle) {
|
|
city->setViewMode(false);
|
|
Vector3D p(cam.getEye());
|
|
create_ped_at(p);
|
|
cam.setVectors( Vector3D(p.x, 10, p.z), Vector3D(p.x, 0.0f, p.z), Vector3D(0, 0, -1) );
|
|
cam.setFollowMode(OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).pos);
|
|
}
|
|
else {
|
|
cam.setVectors(cam.getEye(),
|
|
Vector3D(cam.getEye() + Vector3D(1, -1, 1)), Vector3D(0, 1, 0));
|
|
cam.releaseFollowMode();
|
|
OpenGTA::SpriteManagerHolder::Instance().removePedById(0xffffffff);
|
|
}
|
|
break;
|
|
case SDLK_F5:
|
|
draw_arrows = (draw_arrows ? 0 : 1);
|
|
city->setDrawHeadingArrows(draw_arrows);
|
|
break;
|
|
case SDLK_F6:
|
|
draw_mapmode();
|
|
break;
|
|
case SDLK_F9:
|
|
city->setDrawTextured(city->getDrawTextured() ? 0 : 1);
|
|
break;
|
|
case SDLK_F10:
|
|
city->setDrawLines(city->getDrawLines() ? 0 : 1);
|
|
break;
|
|
/*
|
|
case SDLK_F6:
|
|
tex_flip = (tex_flip ? 0 : 1);
|
|
INFO << "flipping: " << tex_flip << std::endl;
|
|
city->setTexFlipTest(tex_flip);
|
|
break;
|
|
*/
|
|
case '1':
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(1);
|
|
break;
|
|
case '2':
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(2);
|
|
break;
|
|
case '3':
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(3);
|
|
break;
|
|
case '4':
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(4);
|
|
break;
|
|
case '5':
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(5);
|
|
break;
|
|
case '6':
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(6);
|
|
break;
|
|
case '7':
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(7);
|
|
break;
|
|
case '8':
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(8);
|
|
break;
|
|
case '9':
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(9);
|
|
/*
|
|
ped_anim -= 1; if (ped_anim < 0) ped_anim = 0;
|
|
pedAnim.firstFrameOffset = ped_anim;
|
|
INFO << "switching to sprite: " << ped_anim << std::endl;
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).setAnimation(pedAnim);
|
|
*/
|
|
break;
|
|
case '0':
|
|
/*
|
|
ped_anim += 1; if (ped_anim > 200) ped_anim = 200;
|
|
pedAnim.firstFrameOffset = ped_anim;
|
|
INFO << "switching to sprite: " << ped_anim << std::endl;
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).setAnimation(pedAnim);
|
|
*/
|
|
OpenGTA::SpriteManagerHolder::Instance().getPedById(0xffffffff).equip(0);
|
|
break;
|
|
case 'w':
|
|
cam.setSpeed(0.2f);
|
|
break;
|
|
case 's':
|
|
cam.setSpeed(-0.2f);
|
|
break;
|
|
case 'j':
|
|
OpenGTA::LocalPlayer::Instance().turn = 1;
|
|
break;
|
|
case 'l':
|
|
OpenGTA::LocalPlayer::Instance().turn = -1;
|
|
break;
|
|
case 'i':
|
|
OpenGTA::LocalPlayer::Instance().move = (player_toggle_run) ? 2 : 1;
|
|
break;
|
|
case 'k':
|
|
OpenGTA::LocalPlayer::Instance().move = -1;
|
|
break;
|
|
case SDLK_LSHIFT:
|
|
player_toggle_run = (player_toggle_run) ? false : true;
|
|
INFO << player_toggle_run << std::endl;
|
|
break;
|
|
case 'f':
|
|
OpenGL::ScreenHolder::Instance().toggleFullscreen();
|
|
#ifdef WIN32
|
|
city->resetTextures();
|
|
m_font->resetTextures();
|
|
OpenGL::SpriteCacheHolder::Instance().clearAll();
|
|
#endif
|
|
break;
|
|
case 'r':
|
|
rotate = (rotate) ? false : true;
|
|
cam.setRotating(rotate);
|
|
break;
|
|
case 'g':
|
|
cam_grav = (cam_grav) ? false : true;
|
|
cam.setCamGravity(cam_grav);
|
|
break;
|
|
case 't':
|
|
mapPos[0] = mapPos[2] = 128;
|
|
mapPos[1] = 230;
|
|
city->setVisibleRange(128);
|
|
break;
|
|
case 'p':
|
|
print_position();
|
|
break;
|
|
case '+':
|
|
mapPos[1] += 1.0f;
|
|
cam.translateBy(Vector3D(0, 1, 0));
|
|
break;
|
|
case '-':
|
|
mapPos[1] -= 1.0f;
|
|
cam.translateBy(Vector3D(0, -1, 0));
|
|
break;
|
|
case 'x':
|
|
city->setViewMode(false);
|
|
city->setVisibleRange(city->getVisibleRange() * 2);
|
|
break;
|
|
case 'y':
|
|
break;
|
|
case 'z':
|
|
city->setViewMode(true);
|
|
city->setVisibleRange(city->getVisibleRange() / 2);
|
|
break;
|
|
case '.':
|
|
city->setVisibleRange(city->getVisibleRange()-1);
|
|
INFO << " new visible range " << city->getVisibleRange() << std::endl;
|
|
break;
|
|
case ',':
|
|
city->setVisibleRange(city->getVisibleRange()+1);
|
|
INFO << " new visible range " << city->getVisibleRange() << std::endl;
|
|
break;
|
|
case SDLK_PRINT:
|
|
OpenGL::ScreenHolder::Instance().makeScreenshot("screenshot.bmp");
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
city->setPosition(mapPos[0], mapPos[1], mapPos[2]);
|
|
|
|
}
|
|
|
|
void drawScene(Uint32 ticks) {
|
|
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
OpenGL::ScreenHolder::Instance().set3DProjection();
|
|
city->draw(ticks);
|
|
|
|
OpenGL::ScreenHolder::Instance().setFlatProjection();
|
|
|
|
glPushMatrix();
|
|
glTranslatef(10, 10, 0);
|
|
m_font->drawString(city->getCurrentSector()->getFullName());
|
|
glPopMatrix();
|
|
glTranslatef(5, 50, 0);
|
|
std::ostringstream strstr;
|
|
strstr << fps << " fps";
|
|
m_font->drawString(strstr.str());
|
|
|
|
num_frames_drawn += 1;
|
|
|
|
SDL_GL_SwapBuffers();
|
|
}
|
|
|
|
void draw_mapmode() {
|
|
SDL_Event event;
|
|
OpenGL::PagedTexture map_tex = city->renderMap2Texture();
|
|
bool done_map = false;
|
|
OpenGL::Screen & screen = OpenGL::ScreenHolder::Instance();
|
|
screen.setSystemMouseCursor(true);
|
|
GLfloat _scale = 1;
|
|
GLfloat dx = 0;
|
|
GLfloat dy = 0;
|
|
while(!done_map) {
|
|
while (SDL_PollEvent(&event)) {
|
|
switch(event.type) {
|
|
case SDL_QUIT:
|
|
done_map = true;
|
|
break;
|
|
case SDL_KEYDOWN:
|
|
switch(event.key.keysym.sym) {
|
|
case SDLK_ESCAPE:
|
|
done_map = true;
|
|
break;
|
|
case '-':
|
|
_scale += 0.1f;
|
|
break;
|
|
case '+':
|
|
_scale -= 0.1f;
|
|
break;
|
|
case SDLK_LEFT:
|
|
dx -= 0.1f;
|
|
break;
|
|
case SDLK_RIGHT:
|
|
dx += 0.1f;
|
|
break;
|
|
case SDLK_UP:
|
|
dy += 0.1f;
|
|
break;
|
|
case SDLK_DOWN:
|
|
dy -= 0.1f;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case SDL_MOUSEMOTION:
|
|
// std::cout << "Mouse move: x " << event.motion.x << " y " <<
|
|
// event.motion.y << std::endl;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
screen.setFlatProjection();
|
|
glBindTexture(GL_TEXTURE_2D, map_tex.inPage);
|
|
glMatrixMode(GL_TEXTURE);
|
|
glLoadIdentity();
|
|
glScalef(_scale, _scale, 1);
|
|
glTranslatef(dx, dy, 0);
|
|
|
|
glBegin(GL_QUADS);
|
|
glTexCoord2f(map_tex.coords[0].u, map_tex.coords[0].v);
|
|
glVertex2i(0, 0);
|
|
glTexCoord2f(map_tex.coords[1].u, map_tex.coords[0].v);
|
|
glVertex2i(screen.getWidth(), 0);
|
|
glTexCoord2f(map_tex.coords[1].u, map_tex.coords[1].v);
|
|
glVertex2i(screen.getWidth(), screen.getHeight());
|
|
glTexCoord2f(map_tex.coords[0].u, map_tex.coords[1].v);
|
|
glVertex2i(0, screen.getHeight());
|
|
glEnd();
|
|
|
|
SDL_GL_SwapBuffers();
|
|
SDL_Delay(20);
|
|
|
|
}
|
|
screen.setSystemMouseCursor(false);
|
|
glMatrixMode(GL_TEXTURE);
|
|
glLoadIdentity();
|
|
// the texture class doesn't cleanup!
|
|
glDeleteTextures(1, &map_tex.inPage);
|
|
}
|
|
|
|
void parse_args(int argc, char* argv[]) {
|
|
int index;
|
|
int c;
|
|
|
|
opterr = 0;
|
|
|
|
#ifdef WITH_LUA
|
|
#define VIEWER_FLAGS "s:w:h:c:m:g:l:f"
|
|
#else
|
|
#define VIEWER_FLAGS "w:h:c:m:g:l:f"
|
|
#endif
|
|
while ((c = getopt (argc, argv, VIEWER_FLAGS)) != -1)
|
|
switch (c)
|
|
{
|
|
#ifdef WITH_LUA
|
|
case 's':
|
|
script_file = optarg;
|
|
break;
|
|
#endif
|
|
case 'c':
|
|
highcolor_data = atoi(optarg);
|
|
break;
|
|
case 'm':
|
|
specific_map = std::string(optarg);
|
|
break;
|
|
case 'g':
|
|
specific_style = std::string(optarg);
|
|
break;
|
|
case 'w':
|
|
arg_screen_w = atoi(optarg);
|
|
break;
|
|
case 'h':
|
|
arg_screen_h = atoi(optarg);
|
|
break;
|
|
case 'l':
|
|
Util::Log::setOutputLevel(atoi(optarg));
|
|
break;
|
|
case 'f':
|
|
full_screen = true;
|
|
break;
|
|
case '?':
|
|
if (isprint (optopt))
|
|
ERROR << "Unknown option `-" << char(optopt) << "'" << std::endl;
|
|
else
|
|
ERROR << "Unknown option character `" << optopt << "'" << std::endl;
|
|
default:
|
|
abort ();
|
|
}
|
|
|
|
for (index = optind; index < argc; index++)
|
|
city_num = atoi(argv[index]);
|
|
|
|
if (city_num > 2) {
|
|
ERROR << "Invalid city number: " << city_num << std::endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
void run_init() {
|
|
PHYSFS_init("mapview");
|
|
//PHYSFS_addToSearchPath("gtadata.zip", 1);
|
|
Util::FileHelper & fh = GET_FILE_HELPER;
|
|
if (fh.existsInSystemFS(fh.getBaseDataPath()))
|
|
PHYSFS_addToSearchPath(GET_FILE_HELPER.getBaseDataPath().c_str(), 1);
|
|
else {
|
|
WARN << "Could not load data-source: " << fh.getBaseDataPath() <<" -- fallback to current directory"<< std::endl;
|
|
PHYSFS_addToSearchPath(PHYSFS_getBaseDir(), 1);
|
|
}
|
|
if (fh.existsInSystemFS(fh.getModDataPath()))
|
|
PHYSFS_addToSearchPath(GET_FILE_HELPER.getModDataPath().c_str(), 0);
|
|
|
|
OpenGL::Screen & screen = OpenGL::ScreenHolder::Instance();
|
|
screen.setFullScreenFlag(full_screen);
|
|
screen.activate(arg_screen_w, arg_screen_h);
|
|
SDL_EnableKeyRepeat( 100, SDL_DEFAULT_REPEAT_INTERVAL );
|
|
}
|
|
|
|
void run_main() {
|
|
SDL_Event event;
|
|
|
|
m_font = new OpenGL::DrawableFont();
|
|
m_font->loadFont("F_MTEXT.FON");
|
|
m_font->setScale(1);
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
glPolygonMode(GL_FRONT, GL_FILL);
|
|
glEnable(GL_CULL_FACE);
|
|
|
|
//glEnable(GL_BLEND);
|
|
//glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
|
glEnable(GL_ALPHA_TEST);
|
|
glAlphaFunc(GL_GREATER, 0);
|
|
|
|
city = new OpenGTA::CityView();
|
|
if (specific_map.size() > 0 && specific_style.size() > 0) {
|
|
city->loadMap(specific_map, specific_style);
|
|
}
|
|
else {
|
|
if (highcolor_data)
|
|
city->loadMap(cities[city_num], styles_24[city_num]);
|
|
else
|
|
city->loadMap(cities[city_num], styles_8[city_num]);
|
|
}
|
|
city->setPosition(mapPos[0], mapPos[1], mapPos[2]);
|
|
|
|
OpenGL::Camera & cam = OpenGL::CameraHolder::Instance();
|
|
//cam.setVectors( Vector3D(4, 10, 4), Vector3D(4, 0.0f, 4.0f), Vector3D(0, 0, -1) );
|
|
cam.setVectors( Vector3D(12, 20, 12), Vector3D(13.0f, 19.0f, 13.0f), Vector3D(0, 1, 0) );
|
|
|
|
last_tick = SDL_GetTicks();
|
|
#ifdef WITH_LUA
|
|
OpenGTA::Script::LuaVM & vm = OpenGTA::Script::LuaVMHolder::Instance();
|
|
vm.setCityView(*city);
|
|
if (script_file)
|
|
vm.runFile(script_file);
|
|
//vm.runString("function game_tick() print('tick...') end");
|
|
bool vm_tick_ok = true;
|
|
script_last_tick = last_tick;
|
|
#endif
|
|
|
|
|
|
while(!global_Done && !global_EC) {
|
|
while (SDL_PollEvent(&event)) {
|
|
switch(event.type) {
|
|
case SDL_ACTIVEEVENT:
|
|
if (event.active.gain == 0)
|
|
paused = 1;
|
|
else
|
|
paused = 0;
|
|
break;
|
|
case SDL_KEYDOWN:
|
|
handleKeyPress(&event.key.keysym);
|
|
break;
|
|
case SDL_KEYUP:
|
|
handleKeyUp(&event.key.keysym);
|
|
break;
|
|
case SDL_VIDEORESIZE:
|
|
OpenGL::ScreenHolder::Instance().resize(event.resize.w, event.resize.h);
|
|
break;
|
|
case SDL_QUIT:
|
|
global_Done = 1;
|
|
break;
|
|
case SDL_MOUSEMOTION:
|
|
//std::cout << "Mouse move: x " << float(event.motion.x)/screen->w << " y " << float(event.motion.y)/screen->h << std::endl;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
Uint32 now_ticks = SDL_GetTicks();
|
|
OpenGTA::SpriteManagerHolder::Instance().update(now_ticks);
|
|
if (!paused) {
|
|
drawScene(now_ticks - last_tick);
|
|
last_tick = now_ticks;
|
|
#ifdef WITH_LUA
|
|
if (vm_tick_ok && (now_ticks - script_last_tick > 100)) {
|
|
try {
|
|
vm.callSimpleFunction("game_tick");
|
|
script_last_tick = now_ticks;
|
|
}
|
|
catch (Exception & e) {
|
|
vm_tick_ok = false;
|
|
ERROR << "Disabling script game_tick because of error: " << e.what() << std::endl;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
if (now_ticks - fps_last_tick > 2000) {
|
|
fps = num_frames_drawn / 2;
|
|
num_frames_drawn = 0;
|
|
fps_last_tick = now_ticks;
|
|
}
|
|
// SDL_Delay(10);
|
|
}
|
|
}
|