00001
00002
00005 #ifdef WITH_ALLEGRO
00006
00007 #include "../stdafx.h"
00008 #include "../openttd.h"
00009 #include "../debug.h"
00010 #include "../gfx_func.h"
00011 #include "../sdl.h"
00012 #include "../variables.h"
00013 #include "../rev.h"
00014 #include "../blitter/factory.hpp"
00015 #include "../network/network.h"
00016 #include "../core/math_func.hpp"
00017 #include "../core/random_func.hpp"
00018 #include "../functions.h"
00019 #include "../texteff.hpp"
00020 #include "allegro_v.h"
00021 #include <allegro.h>
00022
00023 #ifdef _DEBUG
00024
00025
00026 #include <signal.h>
00027 #endif
00028
00029 static FVideoDriver_Allegro iFVideoDriver_Allegro;
00030
00031 static BITMAP *_allegro_screen;
00032
00033 #define MAX_DIRTY_RECTS 100
00034 static PointDimension _dirty_rects[MAX_DIRTY_RECTS];
00035 static int _num_dirty_rects;
00036
00037 void VideoDriver_Allegro::MakeDirty(int left, int top, int width, int height)
00038 {
00039 if (_num_dirty_rects < MAX_DIRTY_RECTS) {
00040 _dirty_rects[_num_dirty_rects].x = left;
00041 _dirty_rects[_num_dirty_rects].y = top;
00042 _dirty_rects[_num_dirty_rects].width = width;
00043 _dirty_rects[_num_dirty_rects].height = height;
00044 }
00045 _num_dirty_rects++;
00046 }
00047
00048 static void DrawSurfaceToScreen()
00049 {
00050 int n = _num_dirty_rects;
00051 if (n == 0) return;
00052
00053 _num_dirty_rects = 0;
00054 if (n > MAX_DIRTY_RECTS) {
00055 blit(_allegro_screen, screen, 0, 0, 0, 0, _allegro_screen->w, _allegro_screen->h);
00056 return;
00057 }
00058
00059 for (int i = 0; i < n; i++) {
00060 blit(_allegro_screen, screen, _dirty_rects[i].x, _dirty_rects[i].y, _dirty_rects[i].x, _dirty_rects[i].y, _dirty_rects[i].width, _dirty_rects[i].height);
00061 }
00062 }
00063
00064
00065 static void UpdatePalette(uint start, uint count)
00066 {
00067 static PALETTE pal;
00068
00069 uint end = start + count;
00070 for (uint i = start; i != end; i++) {
00071 pal[i].r = _cur_palette[i].r / 4;
00072 pal[i].g = _cur_palette[i].g / 4;
00073 pal[i].b = _cur_palette[i].b / 4;
00074 pal[i].filler = 0;
00075 }
00076
00077 set_palette_range(pal, start, end - 1, 1);
00078 }
00079
00080 static void InitPalette()
00081 {
00082 UpdatePalette(0, 256);
00083 }
00084
00085 static void CheckPaletteAnim()
00086 {
00087 if (_pal_count_dirty != 0) {
00088 Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
00089
00090 switch (blitter->UsePaletteAnimation()) {
00091 case Blitter::PALETTE_ANIMATION_VIDEO_BACKEND:
00092 UpdatePalette(_pal_first_dirty, _pal_count_dirty);
00093 break;
00094
00095 case Blitter::PALETTE_ANIMATION_BLITTER:
00096 blitter->PaletteAnimate(_pal_first_dirty, _pal_count_dirty);
00097 break;
00098
00099 case Blitter::PALETTE_ANIMATION_NONE:
00100 break;
00101
00102 default:
00103 NOT_REACHED();
00104 }
00105 _pal_count_dirty = 0;
00106 }
00107 }
00108
00109 static const Dimension default_resolutions[] = {
00110 { 640, 480},
00111 { 800, 600},
00112 {1024, 768},
00113 {1152, 864},
00114 {1280, 800},
00115 {1280, 960},
00116 {1280, 1024},
00117 {1400, 1050},
00118 {1600, 1200},
00119 {1680, 1050},
00120 {1920, 1200}
00121 };
00122
00123 static void GetVideoModes()
00124 {
00125
00126
00127 set_gfx_mode(_fullscreen ? GFX_AUTODETECT_FULLSCREEN : GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
00128
00129 GFX_MODE_LIST *mode_list = get_gfx_mode_list(gfx_driver->id);
00130 if (mode_list == NULL) {
00131 memcpy(_resolutions, default_resolutions, sizeof(default_resolutions));
00132 _num_resolutions = lengthof(default_resolutions);
00133 return;
00134 }
00135
00136 GFX_MODE *modes = mode_list->mode;
00137
00138 int n = 0;
00139 for (int i = 0; modes[i].bpp != 0; i++) {
00140 int w = modes[i].width;
00141 int h = modes[i].height;
00142 if (w >= 640 && h >= 480) {
00143 int j;
00144 for (j = 0; j < n; j++) {
00145 if (_resolutions[j].width == w && _resolutions[j].height == h) break;
00146 }
00147
00148 if (j == n) {
00149 _resolutions[j].width = w;
00150 _resolutions[j].height = h;
00151 if (++n == lengthof(_resolutions)) break;
00152 }
00153 }
00154 }
00155 _num_resolutions = n;
00156 SortResolutions(_num_resolutions);
00157
00158 destroy_gfx_mode_list(mode_list);
00159 }
00160
00161 static void GetAvailableVideoMode(int *w, int *h)
00162 {
00163
00164 if (_num_resolutions == 0) return;
00165
00166
00167 for (int i = 0; i != _num_resolutions; i++) {
00168 if (*w == _resolutions[i].width && *h == _resolutions[i].height) return;
00169 }
00170
00171
00172 int best = 0;
00173 uint delta = abs((_resolutions[0].width - *w) * (_resolutions[0].height - *h));
00174 for (int i = 1; i != _num_resolutions; ++i) {
00175 uint newdelta = abs((_resolutions[i].width - *w) * (_resolutions[i].height - *h));
00176 if (newdelta < delta) {
00177 best = i;
00178 delta = newdelta;
00179 }
00180 }
00181 *w = _resolutions[best].width;
00182 *h = _resolutions[best].height;
00183 }
00184
00185 static bool CreateMainSurface(int w, int h)
00186 {
00187 int bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth();
00188 if (bpp == 0) usererror("Can't use a blitter that blits 0 bpp for normal visuals");
00189 set_color_depth(bpp);
00190
00191 GetAvailableVideoMode(&w, &h);
00192 if (set_gfx_mode(_fullscreen ? GFX_AUTODETECT_FULLSCREEN : GFX_AUTODETECT_WINDOWED, w, h, 0, 0) != 0) {
00193 DEBUG(driver, 0, "Allegro: Couldn't allocate a window to draw on");
00194 return false;
00195 }
00196
00197
00198
00199 _allegro_screen = create_bitmap_ex(bpp, screen->cr - screen->cl, screen->cb - screen->ct);
00200 _screen.width = _allegro_screen->w;
00201 _screen.height = _allegro_screen->h;
00202 _screen.pitch = ((byte*)screen->line[1] - (byte*)screen->line[0]) / (bpp / 8);
00203
00204
00205 memset(_allegro_screen->line[0], 0, _screen.height * _screen.pitch);
00206
00207
00208 poll_mouse();
00209 _cursor.pos.x = mouse_x;
00210 _cursor.pos.y = mouse_y;
00211
00212 InitPalette();
00213
00214 char caption[32];
00215 snprintf(caption, sizeof(caption), "OpenTTD %s", _openttd_revision);
00216 set_window_title(caption);
00217
00218 GameSizeChanged();
00219
00220 return true;
00221 }
00222
00223 struct VkMapping {
00224 uint16 vk_from;
00225 byte vk_count;
00226 byte map_to;
00227 };
00228
00229 #define AS(x, z) {x, 0, z}
00230 #define AM(x, y, z, w) {x, y - x, z}
00231
00232 static const VkMapping _vk_mapping[] = {
00233
00234 AM(KEY_PGUP, KEY_PGDN, WKC_PAGEUP, WKC_PAGEDOWN),
00235 AS(KEY_UP, WKC_UP),
00236 AS(KEY_DOWN, WKC_DOWN),
00237 AS(KEY_LEFT, WKC_LEFT),
00238 AS(KEY_RIGHT, WKC_RIGHT),
00239
00240 AS(KEY_HOME, WKC_HOME),
00241 AS(KEY_END, WKC_END),
00242
00243 AS(KEY_INSERT, WKC_INSERT),
00244 AS(KEY_DEL, WKC_DELETE),
00245
00246
00247 AM(KEY_A, KEY_Z, 'A', 'Z'),
00248 AM(KEY_0, KEY_9, '0', '9'),
00249
00250 AS(KEY_ESC, WKC_ESC),
00251 AS(KEY_PAUSE, WKC_PAUSE),
00252 AS(KEY_BACKSPACE, WKC_BACKSPACE),
00253
00254 AS(KEY_SPACE, WKC_SPACE),
00255 AS(KEY_ENTER, WKC_RETURN),
00256 AS(KEY_TAB, WKC_TAB),
00257
00258
00259 AM(KEY_F1, KEY_F12, WKC_F1, WKC_F12),
00260
00261
00262 AM(KEY_0_PAD, KEY_9_PAD, '0', '9'),
00263 AS(KEY_SLASH_PAD, WKC_NUM_DIV),
00264 AS(KEY_ASTERISK, WKC_NUM_MUL),
00265 AS(KEY_MINUS_PAD, WKC_NUM_MINUS),
00266 AS(KEY_PLUS_PAD, WKC_NUM_PLUS),
00267 AS(KEY_ENTER_PAD, WKC_NUM_ENTER),
00268 AS(KEY_DEL_PAD, WKC_DELETE),
00269
00270
00271 AS(KEY_SLASH, WKC_SLASH),
00272 AS(KEY_SEMICOLON, WKC_SEMICOLON),
00273 AS(KEY_EQUALS, WKC_EQUALS),
00274 AS(KEY_OPENBRACE, WKC_L_BRACKET),
00275 AS(KEY_BACKSLASH, WKC_BACKSLASH),
00276 AS(KEY_CLOSEBRACE, WKC_R_BRACKET),
00277
00278 AS(KEY_QUOTE, WKC_SINGLEQUOTE),
00279 AS(KEY_COMMA, WKC_COMMA),
00280 AS(KEY_MINUS, WKC_MINUS),
00281 AS(KEY_STOP, WKC_PERIOD),
00282 AS(KEY_TILDE, WKC_BACKQUOTE),
00283 };
00284
00285 static uint32 ConvertAllegroKeyIntoMy()
00286 {
00287 int scancode;
00288 int unicode = ureadkey(&scancode);
00289
00290 const VkMapping *map;
00291 uint key = 0;
00292
00293 for (map = _vk_mapping; map != endof(_vk_mapping); ++map) {
00294 if ((uint)(scancode - map->vk_from) <= map->vk_count) {
00295 key = scancode - map->vk_from + map->map_to;
00296 break;
00297 }
00298 }
00299
00300 if (key_shifts & KB_SHIFT_FLAG) key |= WKC_SHIFT;
00301 if (key_shifts & KB_CTRL_FLAG) key |= WKC_CTRL;
00302 if (key_shifts & KB_ALT_FLAG) key |= WKC_ALT;
00303 #if 0
00304 DEBUG(driver, 0, "Scancode character pressed %u", scancode);
00305 DEBUG(driver, 0, "Unicode character pressed %u", unicode);
00306 #endif
00307 return (key << 16) + unicode;
00308 }
00309
00310 enum {
00311 LEFT_BUTTON,
00312 RIGHT_BUTTON,
00313 };
00314
00315 static void PollEvent()
00316 {
00317 poll_mouse();
00318
00319 bool mouse_action = false;
00320
00321
00322 static int prev_button_state;
00323 if (prev_button_state != mouse_b) {
00324 uint diff = prev_button_state ^ mouse_b;
00325 while (diff != 0) {
00326 int button = FindFirstBit(diff);
00327 ClrBit(diff, button);
00328 if (HasBit(mouse_b, button)) {
00329
00330 if (_rightclick_emulate && key_shifts & KB_CTRL_FLAG) {
00331 button = RIGHT_BUTTON;
00332 ClrBit(diff, RIGHT_BUTTON);
00333 }
00334 switch (button) {
00335 case LEFT_BUTTON:
00336 _left_button_down = true;
00337 break;
00338
00339 case RIGHT_BUTTON:
00340 _right_button_down = true;
00341 _right_button_clicked = true;
00342 break;
00343
00344 default:
00345
00346 break;
00347 }
00348 } else {
00349
00350 if (_rightclick_emulate) {
00351 _right_button_down = false;
00352 _left_button_down = false;
00353 _left_button_clicked = false;
00354 } else if (button == LEFT_BUTTON) {
00355 _left_button_down = false;
00356 _left_button_clicked = false;
00357 } else if (button == RIGHT_BUTTON) {
00358 _right_button_down = false;
00359 }
00360 }
00361 }
00362 prev_button_state = mouse_b;
00363 mouse_action = true;
00364 }
00365
00366
00367 int dx = mouse_x - _cursor.pos.x;
00368 int dy = mouse_y - _cursor.pos.y;
00369 if (dx != 0 || dy != 0) {
00370 if (_cursor.fix_at) {
00371 _cursor.delta.x += dx;
00372 _cursor.delta.y += dy;
00373 position_mouse(_cursor.pos.x, _cursor.pos.y);
00374 } else {
00375 _cursor.delta.x = dx;
00376 _cursor.delta.y = dy;
00377 _cursor.pos.x = mouse_x;
00378 _cursor.pos.y = mouse_y;
00379 _cursor.dirty = true;
00380 }
00381 mouse_action = true;
00382 }
00383
00384 static int prev_mouse_z = 0;
00385 if (prev_mouse_z != mouse_z) {
00386 _cursor.wheel = (prev_mouse_z - mouse_z) < 0 ? -1 : 1;
00387 prev_mouse_z = mouse_z;
00388 mouse_action = true;
00389 }
00390
00391 if (mouse_action) HandleMouseEvents();
00392
00393 poll_keyboard();
00394 if (key_shifts & KB_ALT_FLAG && (key[KEY_ENTER] || key[KEY_F])) {
00395 ToggleFullScreen(!_fullscreen);
00396 } else if (keypressed()) {
00397 HandleKeypress(ConvertAllegroKeyIntoMy());
00398 }
00399 }
00400
00403 int _allegro_instance_count = 0;
00404
00405 const char *VideoDriver_Allegro::Start(const char * const *parm)
00406 {
00407 if (_allegro_instance_count == 0 && install_allegro(SYSTEM_AUTODETECT, &errno, NULL)) return "Failed to set up Allegro";
00408 _allegro_instance_count++;
00409
00410 install_timer();
00411 install_mouse();
00412 install_keyboard();
00413
00414 #if defined _DEBUG
00415
00416
00417 signal(SIGABRT, NULL);
00418 signal(SIGSEGV, NULL);
00419 #endif
00420
00421 #if defined(DOS)
00422
00423
00424 _fullscreen = true;
00425 #endif
00426
00427 GetVideoModes();
00428 if (!CreateMainSurface(_cur_resolution.width, _cur_resolution.height)) {
00429 return "Failed to set up Allegro video";
00430 }
00431 MarkWholeScreenDirty();
00432 set_close_button_callback(HandleExitGameRequest);
00433
00434 return NULL;
00435 }
00436
00437 void VideoDriver_Allegro::Stop()
00438 {
00439 if (--_allegro_instance_count == 0) allegro_exit();
00440 }
00441
00442 #if defined(UNIX) || defined(__OS2__) || defined(PSP) || defined(DOS)
00443 # include <sys/time.h>
00444
00445 static uint32 GetTime()
00446 {
00447 struct timeval tim;
00448
00449 gettimeofday(&tim, NULL);
00450 return tim.tv_usec / 1000 + tim.tv_sec * 1000;
00451 }
00452 #else
00453 static uint32 GetTime()
00454 {
00455 return GetTickCount();
00456 }
00457 #endif
00458
00459
00460 void VideoDriver_Allegro::MainLoop()
00461 {
00462 uint32 cur_ticks = GetTime();
00463 uint32 last_cur_ticks = cur_ticks;
00464 uint32 next_tick = cur_ticks + 30;
00465 uint32 pal_tick = 0;
00466
00467 for (;;) {
00468 uint32 prev_cur_ticks = cur_ticks;
00469 InteractiveRandom();
00470
00471 PollEvent();
00472 if (_exit_game) return;
00473
00474 #if defined(_DEBUG)
00475 if (_shift_pressed)
00476 #else
00477
00478
00479 if (key[KEY_TAB] && (key_shifts & KB_ALT_FLAG) == 0)
00480 #endif
00481 {
00482 if (!_networking && _game_mode != GM_MENU) _fast_forward |= 2;
00483 } else if (_fast_forward & 2) {
00484 _fast_forward = 0;
00485 }
00486
00487 cur_ticks = GetTime();
00488 if (cur_ticks >= next_tick || (_fast_forward && !_pause_game) || cur_ticks < prev_cur_ticks) {
00489 _realtime_tick += cur_ticks - last_cur_ticks;
00490 last_cur_ticks = cur_ticks;
00491 next_tick = cur_ticks + 30;
00492
00493 bool old_ctrl_pressed = _ctrl_pressed;
00494
00495 _ctrl_pressed = !!(key_shifts & KB_CTRL_FLAG);
00496 _shift_pressed = !!(key_shifts & KB_SHIFT_FLAG);
00497
00498
00499 _dirkeys =
00500 (key[KEY_LEFT] ? 1 : 0) |
00501 (key[KEY_UP] ? 2 : 0) |
00502 (key[KEY_RIGHT] ? 4 : 0) |
00503 (key[KEY_DOWN] ? 8 : 0);
00504
00505 if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged();
00506
00507 GameLoop();
00508
00509 _screen.dst_ptr = _allegro_screen->line[0];
00510 UpdateWindows();
00511 if (++pal_tick > 4) {
00512 CheckPaletteAnim();
00513 pal_tick = 1;
00514 }
00515 DrawSurfaceToScreen();
00516 } else {
00517 CSleep(1);
00518 _screen.dst_ptr = _allegro_screen->line[0];
00519 NetworkDrawChatMessage();
00520 DrawMouseCursor();
00521 DrawSurfaceToScreen();
00522 }
00523 }
00524 }
00525
00526 bool VideoDriver_Allegro::ChangeResolution(int w, int h)
00527 {
00528 return CreateMainSurface(w, h);
00529 }
00530
00531 bool VideoDriver_Allegro::ToggleFullscreen(bool fullscreen)
00532 {
00533 #ifdef DOS
00534 return false;
00535 #else
00536 _fullscreen = fullscreen;
00537 GetVideoModes();
00538 if (_num_resolutions == 0 || !this->ChangeResolution(_cur_resolution.width, _cur_resolution.height)) {
00539
00540 _fullscreen ^= true;
00541 return false;
00542 }
00543 return true;
00544 #endif
00545 }
00546
00547 #endif