brumbrumrally-0.7/src/Surface.cpp

/*
 * Copyright 2010, 2011, 2014, 2016 Peter Olsson
 *
 * This file is part of Brum Brum Rally.
 *
 * Brum Brum Rally 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 3 of the License, or
 * (at your option) any later version.
 *
 * Brum Brum Rally 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, see <http://www.gnu.org/licenses/>.
 */

#include "Path.h"
#include "Surface.h"
#include "Font.h"
#include "Vector.h"
#include "SDL_image.h"
#include <climits>
#include <algorithm>
#include <cmath>
#include <sstream>
#include <vector>

Surface::Surface()
:	surface(0),
	clipping(),
	colorKey(),
	importantPixel()
{
	clipping.x = 0;
	clipping.y = 0;
	clipping.w = 0;
	clipping.h = 0;
}

Surface::Surface(int width, int height)
:	colorKey(),
	importantPixel()
{
	SDL_PixelFormat *format = SDL_GetVideoSurface()->format;
	surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, format->BitsPerPixel,
	             format->Rmask, format->Gmask, format->Bmask, format->Amask);

	if (format->BytesPerPixel == 1)
	{
		SDL_SetPalette(surface, SDL_LOGPAL, format->palette->colors, 0, format->palette->ncolors);
	}

	clipping.x = 0;
	clipping.y = 0;
	clipping.w = width;
	clipping.h = height;
	colorKey.unused = true;
}

Surface::Surface(const std::string& filename)
:	colorKey(),
	importantPixel()
{
	SDL_Surface* tempSurface = IMG_Load((dataPath() + filename).c_str());

	clipping.x = 0;
	clipping.y = 0;

	if(!tempSurface)
	{
		clipping.w = 0;
		clipping.h = 0;
		surface = 0;
		return;
	}
	surface = SDL_DisplayFormat(tempSurface);
	SDL_FreeSurface(tempSurface);

	clipping.w = surface->w;
	clipping.h = surface->h;

	colorKey.unused = true;
}

const Font& getSmallFont()
{
	static Font smallFont("small");
	return smallFont;
}

const Font& getBigFont()
{
	static Font smallFont("big");
	return smallFont;
}

const Font& getFont(FontType font)
{
	switch (font)
	{
	case SMALL_FONT:
		return getSmallFont();
	case BIG_FONT:
	default: // Silent warnings.
		return getBigFont();
	}
}


Surface::Surface(const std::string& str, FontType font, Color c)
:	surface(0)
{
	*this = getFont(font).createTextSurface(str, c);
}

Surface::Surface(const std::string& str, FontType font, Color c1, Color c2)
:	surface(0)
{
	*this = getFont(font).createTextSurface(str, c1, c2);
}

Surface::Surface(const Surface& s)
:	surface(s.surface),
	clipping(s.clipping),
	colorKey(s.colorKey),
	importantPixel(s.importantPixel)
{
	if (surface)
	{
		surface->refcount++;
	}
}

Surface::~Surface()
{
	// Note that SDL_FreeSurface will only decrease the refcount
	// if refcount is greater than 1.
	if (surface)
	{
		SDL_FreeSurface(surface);
	}
}

Surface& Surface::operator=(const Surface& s)
{
	if (surface)
	{
		SDL_FreeSurface(surface);
	}
	surface = s.surface;
	if (surface)
	{
		surface->refcount++;
	}
	clipping = s.clipping;
	colorKey = s.colorKey;
	importantPixel = s.importantPixel;

	return *this;
}

Surface Surface::subSurface(int x, int y, int w, int h) const
{
	if (!surface)
	{
		return Surface();
	}

	Surface newSurface = *this;
	newSurface.clipping.x += x;
	newSurface.clipping.y += y;
	newSurface.clipping.w = w;
	newSurface.clipping.h = h;
	newSurface.validateClipping();

	return newSurface;
}

void Surface::setImportantPixel(Uint32 pixelValue)
{
	importantPixel = pixelValue;
}

void Surface::validateClipping()
{
	if (clipping.x >= surface->w)
	{
		clipping.x = surface->w - 1;
	}
	if (clipping.y >= surface->h)
	{
		clipping.y = surface->h - 1;
	}
	if (clipping.x + clipping.w > surface->w)
	{
		clipping.w = surface->w - clipping.x;
	}
	if (clipping.x + clipping.h > surface->h)
	{
		clipping.h = surface->h - clipping.y;
	}
}

void Surface::draw(Surface& dest, int x, int y) const
{
	if (!surface || !dest.surface)
	{
		return;
	}

	// if the destination SDL_Surface object is shared by more than one
	// object we need to make a copy before drawing
	if (dest.surface->refcount > 1)
	{
		dest.surface->refcount--;
		// SDL_DisplayFormat will do the copying
		dest.surface = SDL_DisplayFormat(dest.surface);
	}

	if (colorKey.unused)
	{
		SDL_SetColorKey(surface, 0, 0);
	}
	else
	{
		SDL_SetColorKey(surface, SDL_SRCCOLORKEY, SDL_MapRGB(surface->format, colorKey.r, colorKey.g ,colorKey.b));
	}

	SDL_Rect offset;
	offset.x = x;
	offset.y = y;

	SDL_BlitSurface(surface, &clipping, dest.surface, &offset);
}

Uint32 getPixel(SDL_Surface* surface, Sint16 x, Sint16 y)
{
	if (x >= 0 && y >= 0 && x < surface->w && y < surface->h)
	{
		int bpp = surface->format->BytesPerPixel;
		Uint8 *pixel = (Uint8*)surface->pixels + y * surface->pitch + x * bpp;

		switch(bpp) {
		case 1:
			return *pixel;
		case 2:
			return *(Uint16 *)pixel;
		case 3:
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
			return pixel[0] << 16 | pixel[1] << 8 | pixel[2];
#else
			return pixel[0] | pixel[1] << 8 | pixel[2] << 16;
#endif
		case 4:
			return *(Uint32 *) pixel;
		}
	}
	return 0;
}

void setPixel(SDL_Surface* surface, Sint16 x, Sint16 y, Uint32 value)
{
	if (x >= 0 && y >= 0 && x < surface->w && y < surface->h)
	{
		int bpp = surface->format->BytesPerPixel;
		Uint8 *pixel = (Uint8*)surface->pixels + y * surface->pitch + x * bpp;

		switch (bpp) {
		case 1:
			*pixel = value;
			break;
		case 2:
			(*(Uint16*) pixel) = value;
			break;
		case 3:
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
			pixel[0] = (value >> 16) & 0xFF;
			pixel[1] = (value >> 8)  & 0xFF;
			pixel[2] = (value)       & 0xFF;
#else
			pixel[0] = (value)       & 0xFF;
			pixel[1] = (value >> 8)  & 0xFF;
			pixel[2] = (value >> 16) & 0xFF;
#endif
			break;
		case 4:
			(*(Uint32*) pixel) = value;
			break;
		}
	}
}

static void rotate_draw(SDL_Surface* src, SDL_Surface* dest, int posX, int posY, const SDL_Rect& rect, double angle, Uint32 preservePixelValue)
{
	Vector p1(0, 0);
	p1.rotate(angle);
	Vector p2(rect.w, rect.h);
	p2.rotate(angle);
	Vector p3(0, rect.h);
	p3.rotate(angle);
	Vector p4(rect.w, 0);
	p4.rotate(angle);
	int minX = std::floor(std::min(std::min(std::min(p1.x, p2.x), p3.x), p4.x));
	int minY = std::floor(std::min(std::min(std::min(p1.y, p2.y), p3.y), p4.y));
	int maxX = std::ceil(std::max(std::max(std::max(p1.x, p2.x), p3.x), p4.x));
	int maxY = std::ceil(std::max(std::max(std::max(p1.y, p2.y), p3.y), p4.y));

	int countX = maxX - minX + 1;
	int countY = maxY - minY + 1;

	typedef char PixelBool;
	static std::vector<PixelBool> drawnPixels;
	drawnPixels.resize(countX * countY, false);

	Vector mid(0.5 * rect.w, 0.5 * rect.h);
	Vector midRot(mid);
	midRot.rotate(angle);
	double dx = mid.x + posX - int(midRot.x); // we want to round towards zero, that's why we convert to int here.
	double dy = mid.y + posY - int(midRot.y);

	// rotations is mainly used to rotate cars so by iterating the
	// pixels in reverse order we are less likely to miss the headlights
	for (int y = rect.h - 1; y >= 0; y--)
	{
		for (int x = rect.w - 1; x >= 0; x--)
		{
			Uint32 pxl = getPixel(src, rect.x + x, rect.y + y);
			if (pxl != src->format->colorkey)
			{
				Vector v(x, y);
				v.rotate(angle);

				PixelBool& pixelIsDrawn = drawnPixels[std::floor(dx + v.x) - minX - std::floor(dx) + (std::floor(dy + v.y) - minY  - std::floor(dy)) * countX];
				if (!pixelIsDrawn || pxl == preservePixelValue)
				{
					setPixel(dest, dx + v.x, dy + v.y, pxl);
					pixelIsDrawn = true;
				}
			}
		}
	}

	// fill holes in image
	for (int y = 1; y < countY - 1; y++)
	{
		for (int x = 1; x < countX - 1; x++)
		{
			if (!drawnPixels[x + y * countX] &&
			    drawnPixels[(x + 1) + y * countX] &&
			    drawnPixels[(x - 1) + y * countX] &&
			    drawnPixels[x + (y + 1) * countX] &&
			    drawnPixels[x + (y - 1) * countX] )
			{
				int mx = dest->clip_rect.x + dx + minX + x;
				int my = dest->clip_rect.y + dy + minY + y;
				Uint32 pxl1 = getPixel(dest, mx + 1, my);
				Uint32 pxl2 = getPixel(dest, mx - 1, my);
				Uint32 pxl3 = getPixel(dest, mx, my + 1);
				Uint32 pxl4 = getPixel(dest, mx, my - 1);
				Uint32 pxl;
				// now we want to find the most common neighbor color.
				// it's enough if two color is equal
				if (pxl1 == pxl2 || pxl1 == pxl3 || pxl1 == pxl4)
				{
					pxl = pxl1;
				}
				else if (pxl2 == pxl3 || pxl2 == pxl4)
				{
					pxl = pxl2;
				}
				else if (pxl3 == pxl4)
				{
					pxl = pxl3;
				}
				else
				{
					pxl = pxl4;
				}

				setPixel(dest, dx + minX + x, dy + minY + y, pxl);
			}
		}
	}

	drawnPixels.clear();
}

void Surface::draw(Surface& dest, int x, int y, double angle) const
{
	if (!surface || !dest.surface)
	{
		return;
	}

	// if the destination SDL_Surface object is shared by more than one
	// object we need to make a copy before drawing
	if (dest.surface->refcount > 1)
	{
		dest.surface->refcount--;
		// SDL_DisplayFormat will do the copying
		dest.surface = SDL_DisplayFormat(dest.surface);
	}

	if (colorKey.unused)
	{
		SDL_SetColorKey(surface, 0, 0);
	}
	else
	{
		SDL_SetColorKey(surface, SDL_SRCCOLORKEY, SDL_MapRGB(surface->format, colorKey.r, colorKey.g ,colorKey.b));
	}

	if (angle == 0.0)
	{
		// It is important to handle no rotation in special way to
		// get acceptable performance.
		SDL_Rect offset;
		offset.x = x;
		offset.y = y;
		SDL_BlitSurface(surface, &clipping, dest.surface, &offset);
	}
	else
	{
		rotate_draw(surface, dest.surface, x, y, clipping, angle, importantPixel);
	}
}

int Surface::width() const
{
	return clipping.w;
}
int Surface::height() const
{
	return clipping.h;
}

void Surface::setColorKey(Color c)
{
	colorKey.r = red(c);
	colorKey.g = green(c);
	colorKey.b = blue(c);
	colorKey.unused = false;
}

void Surface::disableColorKey()
{
	colorKey.unused = true;
}

void Surface::fill(Color c, SDL_Rect* rect)
{
	if (surface)
	{
		SDL_PixelFormat* format = surface->format;
		if (surface->refcount > 1)
		{
			surface->refcount--;
			surface = SDL_CreateRGBSurface(SDL_SWSURFACE, surface->w, surface->h, format->BitsPerPixel,
			                               format->Rmask, format->Gmask, format->Bmask, format->Amask);
		}
		SDL_FillRect(surface, rect, SDL_MapRGB(format, red(c), green(c), blue(c)));
	}
}

void Surface::fill(Color c, int x, int y, int w, int h)
{
	SDL_Rect rect;
	rect.x = x;
	rect.y = y;
	rect.w = w;
	rect.h = h;
	fill(c, &rect);
}

void Surface::setColor(int x, int y, Color c)
{
	if (surface)
	{
		setPixel(x, y, SDL_MapRGB(surface->format, red(c), green(c), blue(c)));
	}
}

Color Surface::getColor(int x, int y)
{
	// After we dropped support for bpp < 24 this function should work fine.
	Uint8 r = 0;
	Uint8 g = 0;
	Uint8 b = 0;
	if (surface)
	{
		SDL_GetRGB(getPixel(x, y), surface->format, &r, &g, &b);
	}
	return (r << 16) | (g << 8) | b;
}

void Surface::setPixel(int x, int y, Uint32 pixelValue)
{
	if (surface)
	{
		::setPixel(surface, clipping.x + x, clipping.y + y, pixelValue);
	}
}

Uint32 Surface::getPixel(int x, int y) const
{
	if (!surface)
	{
		return 0;
	}
	return ::getPixel(surface, clipping.x + x, clipping.y + y);
}