1

#include "stdafx.h"

     2

     3

#if defined(WITH_SDL)

     4

#include "ttd.h"

     5

#include "gfx.h"

     6

#include "sound.h"

     7

#include "window.h"

     8

#include <SDL.h>

     9

#include "player.h"

    10

#include "hal.h"

    11

    12

#ifdef UNIX

    13

#include <signal.h>

    14

#endif

    15

    16

#define DYNAMICALLY_LOADED_SDL

    17

    18

static SDL_Surface *_sdl_screen;

    19

static int _sdl_usage;

    20

static bool _all_modes;

    21

    22

#define MAX_DIRTY_RECTS 100

    23

static SDL_Rect _dirty_rects[MAX_DIRTY_RECTS];

    24

static int _num_dirty_rects;

    25

    26

#define SDL_CALL

    27

    28

#if defined(DYNAMICALLY_LOADED_SDL) && defined(WIN32)

    29

    30

bool LoadLibraryList(void **proc, const char *dll);

    31

    32

typedef struct {

    33

	int (SDLCALL *SDL_Init)(Uint32);

    34

	int (SDLCALL *SDL_InitSubSystem)(Uint32);

    35

	char *(SDLCALL *SDL_GetError)();

    36

	void (SDLCALL *SDL_QuitSubSystem)(Uint32);

    37

	void (SDLCALL *SDL_UpdateRect)(SDL_Surface *, Sint32, Sint32, Uint32, Uint32);

    38

	void (SDLCALL *SDL_UpdateRects)(SDL_Surface *, int, SDL_Rect *);

    39

	int (SDLCALL *SDL_SetColors)(SDL_Surface *, SDL_Color *, int, int);

    40

	void (SDLCALL *SDL_WM_SetCaption)(const char *, const char *);

    41

	int (SDLCALL *SDL_ShowCursor)(int);

    42

	void (SDLCALL *SDL_FreeSurface)(SDL_Surface *);

    43

	int (SDLCALL *SDL_PollEvent)(SDL_Event *);

    44

	void (SDLCALL *SDL_WarpMouse)(Uint16, Uint16);

    45

	uint32 (SDLCALL *SDL_GetTicks)();

    46

	int (SDLCALL *SDL_OpenAudio)(SDL_AudioSpec *, SDL_AudioSpec*);

    47

	void (SDLCALL *SDL_PauseAudio)(int);

    48

	void (SDLCALL *SDL_CloseAudio)();

    49

	int (SDLCALL *SDL_LockSurface)(SDL_Surface*);

    50

	void (SDLCALL *SDL_UnlockSurface)(SDL_Surface*);

    51

	SDLMod (SDLCALL *SDL_GetModState)();

    52

	void (SDLCALL *SDL_Delay)(Uint32);

    53

	void (SDLCALL *SDL_Quit)();

    56

	void (SDLCALL *SDL_EnableUNICODE)(int);

    57

	void (SDLCALL *SDL_VideoDriverName)(char *, int);

    58

	SDL_Rect **(SDLCALL *SDL_ListModes)(void *, int);

    59

	Uint8 *(SDLCALL *SDL_GetKeyState)(int *);

    60

} SDLProcs;

    61

    62

#define M(x) x "\0"

    63

static const char sdl_files[] =

    64

	M("sdl.dll")

    65

	M("SDL_Init")

    66

	M("SDL_InitSubSystem")

    67

	M("SDL_GetError")

    68

	M("SDL_QuitSubSystem")

    69

	M("SDL_UpdateRect")

    70

	M("SDL_UpdateRects")

    71

	M("SDL_SetColors")

    72

	M("SDL_WM_SetCaption")

    73

	M("SDL_ShowCursor")

    74

	M("SDL_FreeSurface")

    75

	M("SDL_PollEvent")

    76

	M("SDL_WarpMouse")

    77

	M("SDL_GetTicks")

    78

	M("SDL_OpenAudio")

    79

	M("SDL_PauseAudio")

    80

	M("SDL_CloseAudio")

    81

	M("SDL_LockSurface")

    82

	M("SDL_UnlockSurface")

    83

	M("SDL_GetModState")

    84

	M("SDL_Delay")

    85

	M("SDL_Quit")

    86

	M("SDL_SetVideoMode")

    87

	M("SDL_EnableKeyRepeat")

    88

	M("SDL_EnableUNICODE")

    89

	M("SDL_VideoDriverName")

    90

	M("SDL_ListModes")

    91

	M("SDL_GetKeyState")

    92

	M("")

    93

;

    94

#undef M

    95

    96

static SDLProcs _proc;

    97

    99

{

   100

	if (_proc.SDL_Init != NULL)

   101

		return NULL;

   102

	if (!LoadLibraryList((void**)&_proc, sdl_files))

   103

		return "Unable to load sdl.dll";

   104

	return NULL;

   105

}

   106

   107

#undef SDL_CALL

   108

#define SDL_CALL _proc.

   109

   110

#endif

   111

   112

   113

#ifdef UNIX

   114

static void SdlAbort(int sig)

   115

{

   116

	/* Own hand-made parachute for the cases of failed assertions. */

   117

	SDL_CALL SDL_Quit();

   118

}

   119

#endif

   120

   121

   122

static char *SdlOpen(uint32 x)

   123

{

   124

#if defined(DYNAMICALLY_LOADED_SDL) && defined(WIN32)

   129

#endif

   130

	if (_sdl_usage++ == 0) {

   131

		if (SDL_CALL SDL_Init(x) == -1)

   132

			return SDL_CALL SDL_GetError();

   134

		if (SDL_CALL SDL_InitSubSystem(x) == -1)

   135

			return SDL_CALL SDL_GetError();

   136

	}

   137

   138

#ifdef UNIX

   139

	signal(SIGABRT, SdlAbort);

   140

#endif

   141

   142

	return NULL;

   143

}

   144

   145

static void SdlClose(uint32 x)

   146

{

   148

		SDL_CALL SDL_QuitSubSystem(x);

   149

	if (--_sdl_usage == 0) {

   150

		SDL_CALL SDL_Quit();

   158

	}

   159

}

   160

   161

static void SdlVideoMakeDirty(int left, int top, int width, int height)

   162

{

   163

//	printf("(%d,%d)-(%d,%d)\n", left, top, width, height);

   164

//	_pixels_redrawn += width*height;

   165

	if (_num_dirty_rects < MAX_DIRTY_RECTS) {

   166

		_dirty_rects[_num_dirty_rects].x = left;

   167

		_dirty_rects[_num_dirty_rects].y = top;

   168

		_dirty_rects[_num_dirty_rects].w = width;

   169

		_dirty_rects[_num_dirty_rects].h = height;

   170

	}

   171

	_num_dirty_rects++;

   172

}

   173

   174

static SDL_Color pal[256];

   175

   178

	uint i;

   179

	byte *b;

   180

   182

		pal[i].r = b[0];

   183

		pal[i].g = b[1];

   184

		pal[i].b = b[2];

   185

		pal[i].unused = b[3];

   186

	}

   187

   188

	SDL_CALL SDL_SetColors(_sdl_screen, pal, start, end);

   189

}

   190

   193

	UpdatePalette(0, 256);

   194

}

   195

   197

{

   198

	if(_pal_last_dirty != -1) {

   199

		UpdatePalette(_pal_first_dirty, _pal_last_dirty + 1);

   200

		_pal_last_dirty = -1;

   201

	}

   202

}

   203

   205

{

   208

		_num_dirty_rects = 0;

   209

		if (n > MAX_DIRTY_RECTS)

   210

			SDL_CALL SDL_UpdateRect(_sdl_screen, 0, 0, 0, 0);

   212

			SDL_CALL SDL_UpdateRects(_sdl_screen, n, _dirty_rects);

   213

	}

   214

}

   215

   216

static int CDECL compare_res(const void *pa, const void *pb)

   217

{

   218

	int x = ((const uint16*)pa)[0] - ((const uint16*)pb)[0];

   220

	return ((const uint16*)pa)[1] - ((const uint16*)pb)[1];

   221

}

   222

   223

static const uint16 default_resolutions[][2] = {

   232

};

   233

   236

	int i;

   237

	SDL_Rect **modes;

   238

   239

	modes = SDL_CALL SDL_ListModes(NULL, SDL_SWSURFACE + (_fullscreen ? SDL_FULLSCREEN : 0));

   240

   242

		error("sdl: no modes available");

   243

   244

	_all_modes = (modes == (void*)-1);

   245

   246

	if (_all_modes) {

   247

		// all modes available, put some default ones here

   248

		memcpy(_resolutions, default_resolutions, sizeof(default_resolutions));

   249

		_num_resolutions = lengthof(default_resolutions);

   250

	} else {

   251

		int n = 0;

   253

			int w = modes[i]->w;

   254

			int h = modes[i]->h;

   255

			if (IS_INT_INSIDE(w, 640, MAX_SCREEN_WIDTH + 1) &&

   256

					IS_INT_INSIDE(h, 480, MAX_SCREEN_HEIGHT + 1)) {

   257

				int j;

   258

				for (j = 0; j < n; ++j)

   259

					if (_resolutions[j][0] == w && _resolutions[j][1] == h)

   260

						break;

   261

				if (j == n) {

   262

					_resolutions[n][0] = w;

   263

					_resolutions[n][1] = h;

   264

					if (++n == lengthof(_resolutions)) break;

   265

				}

   266

			}

   267

		}

   268

		_num_resolutions = n;

   269

		qsort(_resolutions, n, sizeof(_resolutions[0]), compare_res);

   270

	}

   271

}

   272

   273

static int GetAvailableVideoMode(int *w, int *h)

   274

{

   275

	int i;

   276

	int best;

   277

	uint delta;

   278

   279

	// all modes available?

   280

	if (_all_modes)

   281

		return 1;

   282

   283

	// is the wanted mode among the available modes?

   284

	for (i = 0; i != _num_resolutions; i++) {

   285

		if(*w == _resolutions[i][0] && *h == _resolutions[i][1])

   286

			return 1;

   287

	}

   288

   289

	// use the closest possible resolution

   290

	best = 0;

   291

	delta = abs((_resolutions[0][0] - *w) * (_resolutions[0][1] - *h));

   292

	for (i = 1; i != _num_resolutions; ++i) {

   293

		uint newdelta = abs((_resolutions[i][0] - *w) * (_resolutions[i][1] - *h));

   294

		if (newdelta < delta) {

   295

			best = i;

   296

			delta = newdelta;

   297

		}

   298

	}

   299

	*w = _resolutions[best][0];

   300

	*h = _resolutions[best][1];

   301

	return 2;

   302

}

   303

   304

static bool CreateMainSurface(int w, int h)

   305

{

   306

	SDL_Surface *newscreen;

   307

   308

	GetAvailableVideoMode(&w, &h);

   309

   310

	DEBUG(misc, 0) ("sdl: using mode %dx%d", w, h);

   311

   312

	// DO NOT CHANGE TO HWSURFACE, IT DOES NOT WORK

   315

		return false;

   316

   317

	_screen.width = newscreen->w;

   318

	_screen.height = newscreen->h;

   319

	_screen.pitch = newscreen->pitch;

   320

   321

	_sdl_screen = newscreen;

   322

	InitPalette();

   323

   324

	SDL_CALL SDL_WM_SetCaption("OpenTTD", "OpenTTD");

   325

	SDL_CALL SDL_ShowCursor(0);

   326

   327

	GameSizeChanged();

   328

   329

	return true;

   330

}

   331

   333

	uint16 vk_from;

   334

	byte vk_count;

   335

	byte map_to;

   336

} VkMapping;

   337

   340

   341

static const VkMapping _vk_mapping[] = {

   342

	// Pageup stuff + up/down

   344

	AS(SDLK_UP,			WKC_UP),

   345

	AS(SDLK_DOWN,		WKC_DOWN),

   346

	AS(SDLK_LEFT,		WKC_LEFT),

   347

	AS(SDLK_RIGHT,	WKC_RIGHT),

   348

   349

	AS(SDLK_HOME,		WKC_HOME),

   350

	AS(SDLK_END,		WKC_END),

   351

   352

	AS(SDLK_INSERT,	WKC_INSERT),

   353

	AS(SDLK_DELETE,	WKC_DELETE),

   354

   355

	// Map letters & digits

   358

   359

	AS(SDLK_ESCAPE,	WKC_ESC),

   360

	AS(SDLK_BACKSPACE,	WKC_BACKSPACE),

   361

   362

	AS(SDLK_SPACE,		WKC_SPACE),

   363

	AS(SDLK_RETURN,		WKC_RETURN),

   364

	AS(SDLK_TAB,			WKC_TAB),

   365

   366

	// Function keys

   368

   369

	// Numeric part.

   370

	// What is the virtual keycode for numeric enter??

   372

	AS(SDLK_KP_DIVIDE,		WKC_NUM_DIV),

   373

	AS(SDLK_KP_MULTIPLY,	WKC_NUM_MUL),

   374

	AS(SDLK_KP_MINUS,			WKC_NUM_MINUS),

   375

	AS(SDLK_KP_PLUS,			WKC_NUM_PLUS),

   376

	AS(SDLK_KP_ENTER,			WKC_NUM_ENTER),

   378

};

   379

   380

static uint32 ConvertSdlKeyIntoMy(SDL_keysym *sym)

   381

{

   387

			break;

   388

		}

   389

	}

   390

   391

	// check scancode for BACKQUOTE key, because we want the key left of "1", not anything else (on non-US keyboards)

   392

#if defined(WIN32)

   393

	if (sym->scancode == 41) key |= WKC_BACKQUOTE;

   398

#else

   400

#endif

   401

	// META are the command keys on mac

   402

	if (sym->mod & KMOD_META) key |= WKC_META;

   403

	if (sym->mod & KMOD_SHIFT) key |= WKC_SHIFT;

   404

	if (sym->mod & KMOD_CTRL) key |= WKC_CTRL;

   405

	if (sym->mod & KMOD_ALT) key |= WKC_ALT;

   407

	//printf("scancode character pressed %d\n", sym->scancode);

   408

	//printf("unicode character pressed %d\n", sym->unicode);

   409

	return (key << 16) + sym->unicode;

   410

}

   411

   414

	SDL_Event ev;

   415

   416

	if (!SDL_CALL SDL_PollEvent(&ev))

   417

		return -2;

   418

   420

	case SDL_MOUSEMOTION:

   421

		if (_cursor.fix_at) {

   422

			int dx = ev.motion.x - _cursor.pos.x;

   423

			int dy = ev.motion.y - _cursor.pos.y;

   424

			if (dx != 0 || dy != 0) {

   425

				_cursor.delta.x += dx;

   426

				_cursor.delta.y += dy;

   427

				SDL_CALL SDL_WarpMouse(_cursor.pos.x, _cursor.pos.y);

   428

			}

   429

		} else {

   430

			_cursor.delta.x = ev.motion.x - _cursor.pos.x;

   431

			_cursor.delta.y = ev.motion.y - _cursor.pos.y;

   432

			_cursor.pos.x = ev.motion.x;

   433

			_cursor.pos.y = ev.motion.y;

   434

			_cursor.dirty = true;

   435

		}

   436

		break;

   437

   438

	case SDL_MOUSEBUTTONDOWN:

   439

		if (_rightclick_emulate && (SDL_CALL SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL)))

   440

			ev.button.button = SDL_BUTTON_RIGHT;

   441

   460

		}

   461

		break;

   462

   463

	case SDL_MOUSEBUTTONUP:

   464

		if (_rightclick_emulate) {

   465

			_right_button_down = false;

   466

			_left_button_down = false;

   467

			_left_button_clicked = false;

   468

		} else if (ev.button.button == SDL_BUTTON_LEFT) {

   469

			_left_button_down = false;

   470

			_left_button_clicked = false;

   471

		} else if (ev.button.button == SDL_BUTTON_RIGHT) {

   472

			_right_button_down = false;

   473

		}

   474

		break;

   475

   476

	case SDL_QUIT:

   477

		// do not ask to quit on the main screen

   479

			AskExitGame();

   480

		else

   481

			return ML_QUIT;

   482

		break;

   483

   484

	case SDL_KEYDOWN:

   487

			_fullscreen ^= true;

   488

			GetVideoModes();

   489

			CreateMainSurface(_screen.width, _screen.height);

   490

			MarkWholeScreenDirty();

   491

		} else {

   492

			_pressed_key = ConvertSdlKeyIntoMy(&ev.key.keysym);

   493

		}

   494

		break;

   495

   496

	case SDL_VIDEORESIZE: {

   502

	}

   503

	return -1;

   504

}

   505

   506

static const char *SdlVideoStart(char **parm)

   507

{

   509