static FVideoDriver_SDL iFVideoDriver_SDL;

static SDL_Surface *_sdl_surface;

static SDL_Surface *_sdl_rgb_surface;

static SDL_Surface *_sdl_real_surface;

static SDL_Palette *_sdl_palette;

void VideoDriver_SDL::MakeDirty(int left, int top, int width, int height)

void VideoDriver_SDL::UpdatePalette()

{

	SDL_Color pal[256];

	for (int i = 0; i != this->local_palette.count_dirty; i++) {

		pal[i].r = this->local_palette.palette[this->local_palette.first_dirty + i].r;

		pal[i].g = this->local_palette.palette[this->local_palette.first_dirty + i].g;

		pal[i].b = this->local_palette.palette[this->local_palette.first_dirty + i].b;

		pal[i].a = 0;

	}

	SDL_SetPaletteColors(_sdl_palette, pal, this->local_palette.first_dirty, this->local_palette.count_dirty);

	SDL_SetSurfacePalette(_sdl_surface, _sdl_palette);

}

void VideoDriver_SDL::MakePalette()

{

	if (_sdl_palette == nullptr) {

		_sdl_palette = SDL_AllocPalette(256);

		if (_sdl_palette == nullptr) usererror("SDL2: Couldn't allocate palette: %s", SDL_GetError());

	}

	_cur_palette.first_dirty = 0;

	_cur_palette.count_dirty = 256;

	this->local_palette = _cur_palette;

	this->UpdatePalette();

	if (_sdl_surface != _sdl_real_surface) {

		/* When using a shadow surface, also set our palette on the real screen. This lets SDL

		 * allocate as many colors (or approximations) as

		 * possible, instead of using only the default SDL

		 * palette. This allows us to get more colors exactly

		 * right and might allow using better approximations for

		 * other colors.

		 *

		 * Note that colors allocations are tried in-order, so

		 * this favors colors further up into the palette. Also

		 * note that if two colors from the same animation

		 * sequence are approximated using the same color, that

		 * animation will stop working.

		 *

		 * Since changing the system palette causes the colours

		 * to change right away, and allocations might

		 * drastically change, we can't use this for animation,

		 * since that could cause weird coloring between the

		 * palette change and the blitting below, so we only set

		 * the real palette during initialisation.

		 */

		SDL_SetSurfacePalette(_sdl_real_surface, _sdl_palette);

	}

}

void VideoDriver_SDL::CheckPaletteAnim()

void VideoDriver_SDL::Paint()

{

	PerformanceMeasurer framerate(PFE_VIDEO);

	if (IsEmptyRect(this->dirty_rect) && _cur_palette.count_dirty == 0) return;

	if (_cur_palette.count_dirty != 0) {

		Blitter *blitter = BlitterFactory::GetCurrentBlitter();

		switch (blitter->UsePaletteAnimation()) {

			case Blitter::PALETTE_ANIMATION_VIDEO_BACKEND:

				this->UpdatePalette();

				break;

			case Blitter::PALETTE_ANIMATION_BLITTER: {

				bool need_buf = _screen.dst_ptr == nullptr;

				if (need_buf) _screen.dst_ptr = this->GetVideoPointer();

				blitter->PaletteAnimate(this->local_palette);

				if (need_buf) {

					this->ReleaseVideoPointer();

					_screen.dst_ptr = nullptr;

				}

				break;

			}

			case Blitter::PALETTE_ANIMATION_NONE:

				break;

			default:

				NOT_REACHED();

		}

		_cur_palette.count_dirty = 0;

	}

	SDL_Rect r = { this->dirty_rect.left, this->dirty_rect.top, this->dirty_rect.right - this->dirty_rect.left, this->dirty_rect.bottom - this->dirty_rect.top };

	if (_sdl_surface != _sdl_real_surface) {

		SDL_BlitSurface(_sdl_surface, &r, _sdl_real_surface, &r);

	}

	SDL_UpdateWindowSurfaceRects(this->sdl_window, &r, 1);

	this->dirty_rect = {};

}

void VideoDriver_SDL::PaintThread()

{

	/* First tell the main thread we're started */

	std::unique_lock<std::recursive_mutex> lock(*this->draw_mutex);

	this->draw_signal->notify_one();

	/* Now wait for the first thing to draw! */

	this->draw_signal->wait(*this->draw_mutex);

	while (this->draw_continue) {

		/* Then just draw and wait till we stop */

		this->Paint();

		this->draw_signal->wait(lock);

	}

}

/* static */ void VideoDriver_SDL::PaintThreadThunk(VideoDriver_SDL *drv)

void VideoDriver_SDL::ClientSizeChanged(int w, int h, bool force)

bool VideoDriver_SDL::CreateMainWindow(uint w, uint h, uint flags)

bool VideoDriver_SDL::CreateMainSurface(uint w, uint h, bool resize)

bool VideoDriver_SDL::AllocateBackingStore(int w, int h, bool force)

{

	int bpp = BlitterFactory::GetCurrentBlitter()->GetScreenDepth();

	_sdl_real_surface = SDL_GetWindowSurface(this->sdl_window);

	if (_sdl_real_surface == nullptr) usererror("SDL2: Couldn't get window surface: %s", SDL_GetError());

	if (!force && w == _sdl_real_surface->w && h == _sdl_real_surface->h) return false;

	/* Free any previously allocated rgb surface. */

	if (_sdl_rgb_surface != nullptr) {

		SDL_FreeSurface(_sdl_rgb_surface);

		_sdl_rgb_surface = nullptr;

	}

	if (bpp == 8) {

		_sdl_rgb_surface = SDL_CreateRGBSurface(0, w, h, 8, 0, 0, 0, 0);

		if (_sdl_rgb_surface == nullptr) usererror("SDL2: Couldn't allocate shadow surface: %s", SDL_GetError());

		_sdl_surface = _sdl_rgb_surface;

	} else {

		_sdl_surface = _sdl_real_surface;

	}

	/* X11 doesn't appreciate it if we invalidate areas outside the window

	 * if shared memory is enabled (read: it crashes). So, as we might have

	 * gotten smaller, reset our dirty rects. GameSizeChanged() a bit lower

	 * will mark the whole screen dirty again anyway, but this time with the

	 * new dimensions. */

	this->dirty_rect = {};

	_screen.width = _sdl_surface->w;

	_screen.height = _sdl_surface->h;

	_screen.pitch = _sdl_surface->pitch / (bpp / 8);

	_screen.dst_ptr = this->GetVideoPointer();

	this->MakePalette();

	return true;

}

void *VideoDriver_SDL::GetVideoPointer()

{

	return _sdl_surface->pixels;

}

bool VideoDriver_SDL::ClaimMousePointer()

void VideoDriver_SDL::EditBoxGainedFocus()

void VideoDriver_SDL::EditBoxLostFocus()

int VideoDriver_SDL::PollEvent()

const char *VideoDriver_SDL::Initialize()

const char *VideoDriver_SDL::Start(const StringList &parm)

void VideoDriver_SDL::Stop()

void VideoDriver_SDL::InputLoop()

void VideoDriver_SDL::LoopOnce()

void VideoDriver_SDL::MainLoop()

			this->draw_threaded = StartNewThread(&draw_thread, "ottd:draw-sdl", &VideoDriver_SDL::PaintThreadThunk, this);

void VideoDriver_SDL::MainLoopCleanup()

bool VideoDriver_SDL::ChangeResolution(int w, int h)

bool VideoDriver_SDL::ToggleFullscreen(bool fullscreen)

bool VideoDriver_SDL::AfterBlitterChange()

void VideoDriver_SDL::AcquireBlitterLock()

void VideoDriver_SDL::ReleaseBlitterLock()

Dimension VideoDriver_SDL::GetScreenSize() const

bool VideoDriver_SDL::LockVideoBuffer()

void VideoDriver_SDL::UnlockVideoBuffer()