diff --git a/source.list b/source.list
index 3e29ab45fe..7a500c3d97 100644
--- a/source.list
+++ b/source.list
@@ -904,6 +904,12 @@ script/api/script_window.cpp
# Blitters
#if DEDICATED
#else
+blitter/16bpp_base.cpp
+blitter/16bpp_base.hpp
+# blitter/16bpp_anim.cpp
+# blitter/16bpp_anim.hpp
+blitter/16bpp_simple.cpp
+blitter/16bpp_simple.hpp
blitter/32bpp_anim.cpp
blitter/32bpp_anim.hpp
#if SSE
diff --git a/src/blitter/16bpp_base.cpp b/src/blitter/16bpp_base.cpp
new file mode 100644
index 0000000000..69424fad4d
--- /dev/null
+++ b/src/blitter/16bpp_base.cpp
@@ -0,0 +1,147 @@
+/* $Id$ */
+
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD 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, version 2.
+ * OpenTTD 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 OpenTTD. If not, see .
+ */
+
+/** @file 16bpp_base.cpp Implementation of base for 32 bpp blitters. */
+
+#include "../stdafx.h"
+#include "16bpp_base.hpp"
+
+void *Blitter_16bppBase::MoveTo(void *video, int x, int y)
+{
+ return (uint16 *)video + x + y * _screen.pitch;
+}
+
+void Blitter_16bppBase::SetPixel(void *video, int x, int y, uint8 colour)
+{
+ *((Colour16 *)video + x + y * _screen.pitch) = LookupColourInPalette(colour);
+}
+
+void Blitter_16bppBase::DrawRect(void *video, int width, int height, uint8 colour)
+{
+ Colour16 target = LookupColourInPalette(colour);
+
+ do {
+ Colour16 *dst = (Colour16 *)video;
+ for (int i = width; i > 0; i--) {
+ *dst = target;
+ dst++;
+ }
+ video = (uint16 *)video + _screen.pitch;
+ } while (--height);
+}
+
+void Blitter_16bppBase::CopyFromBuffer(void *video, const void *src, int width, int height)
+{
+ uint16 *dst = (uint16 *)video;
+ const uint16 *usrc = (const uint16 *)src;
+
+ for (; height > 0; height--) {
+ memcpy(dst, usrc, width * sizeof(uint16));
+ usrc += width;
+ dst += _screen.pitch;
+ }
+}
+
+void Blitter_16bppBase::CopyToBuffer(const void *video, void *dst, int width, int height)
+{
+ uint16 *udst = (uint16 *)dst;
+ const uint16 *src = (const uint16 *)video;
+
+ for (; height > 0; height--) {
+ memcpy(udst, src, width * sizeof(uint16));
+ src += _screen.pitch;
+ udst += width;
+ }
+}
+
+void Blitter_16bppBase::CopyImageToBuffer(const void *video, void *dst, int width, int height, int dst_pitch)
+{
+ uint16 *udst = (uint16 *)dst;
+ const uint16 *src = (const uint16 *)video;
+
+ for (; height > 0; height--) {
+ memcpy(udst, src, width * sizeof(uint16));
+ src += _screen.pitch;
+ udst += dst_pitch;
+ }
+}
+
+void Blitter_16bppBase::ScrollBuffer(void *video, int &left, int &top, int &width, int &height, int scroll_x, int scroll_y)
+{
+ const uint16 *src;
+ uint16 *dst;
+
+ if (scroll_y > 0) {
+ /* Calculate pointers */
+ dst = (uint16 *)video + left + (top + height - 1) * _screen.pitch;
+ src = dst - scroll_y * _screen.pitch;
+
+ /* Decrease height and increase top */
+ top += scroll_y;
+ height -= scroll_y;
+ assert(height > 0);
+
+ /* Adjust left & width */
+ if (scroll_x >= 0) {
+ dst += scroll_x;
+ left += scroll_x;
+ width -= scroll_x;
+ } else {
+ src -= scroll_x;
+ width += scroll_x;
+ }
+
+ for (int h = height; h > 0; h--) {
+ memcpy(dst, src, width * sizeof(uint16));
+ src -= _screen.pitch;
+ dst -= _screen.pitch;
+ }
+ } else {
+ /* Calculate pointers */
+ dst = (uint16 *)video + left + top * _screen.pitch;
+ src = dst - scroll_y * _screen.pitch;
+
+ /* Decrease height. (scroll_y is <=0). */
+ height += scroll_y;
+ assert(height > 0);
+
+ /* Adjust left & width */
+ if (scroll_x >= 0) {
+ dst += scroll_x;
+ left += scroll_x;
+ width -= scroll_x;
+ } else {
+ src -= scroll_x;
+ width += scroll_x;
+ }
+
+ /* the y-displacement may be 0 therefore we have to use memmove,
+ * because source and destination may overlap */
+ for (int h = height; h > 0; h--) {
+ memmove(dst, src, width * sizeof(uint16));
+ src += _screen.pitch;
+ dst += _screen.pitch;
+ }
+ }
+}
+
+int Blitter_16bppBase::BufferSize(int width, int height)
+{
+ return width * height * sizeof(uint16);
+}
+
+void Blitter_16bppBase::PaletteAnimate(const Palette &palette)
+{
+ /* By default, 16bpp doesn't have palette animation */
+}
+
+Blitter::PaletteAnimation Blitter_16bppBase::UsePaletteAnimation()
+{
+ return Blitter::PALETTE_ANIMATION_NONE;
+}
diff --git a/src/blitter/16bpp_base.hpp b/src/blitter/16bpp_base.hpp
new file mode 100644
index 0000000000..e5425d809f
--- /dev/null
+++ b/src/blitter/16bpp_base.hpp
@@ -0,0 +1,208 @@
+/* $Id$ */
+
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD 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, version 2.
+ * OpenTTD 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 OpenTTD. If not, see .
+ */
+
+/** @file 16bpp_base.hpp Base for all 16 bits blitters. */
+
+#ifndef BLITTER_16BPP_BASE_HPP
+#define BLITTER_16BPP_BASE_HPP
+
+#include "base.hpp"
+#include "../core/bitmath_func.hpp"
+#include "../core/math_func.hpp"
+#include "../gfx_func.h"
+
+/** Base for all 16bpp blitters. */
+class Blitter_16bppBase : public Blitter {
+public:
+
+ // TODO: GCC-specific attributes
+ struct Colour16 {
+ unsigned b : 5 __attribute__((packed)); ///< Blue-channel, packed 5 bits
+ unsigned g : 6 __attribute__((packed)); ///< Green-channel, packed 6 bits
+ unsigned r : 5 __attribute__((packed)); ///< Red-channel, packed 5 bits
+ Colour16(uint8 r, uint8 g, uint8 b):
+ b(b), g(g), r(r)
+ {
+ }
+ };
+
+ struct Pixel {
+ Colour16 c;
+ unsigned a : 4 __attribute__((packed)); ///< Alpha-channel, packed 4 bits
+ unsigned v : 4 __attribute__((packed)); ///< Brightness-channel, packed 4 bits
+ unsigned m : 8 __attribute__((packed)); ///< Remap-channel, cannot pack it, because it's palette lookup index, so it must be in range 0-255
+ };
+
+ /* virtual */ uint8 GetScreenDepth() { return 16; }
+ /* virtual */ void *MoveTo(void *video, int x, int y);
+ /* virtual */ void SetPixel(void *video, int x, int y, uint8 colour);
+ /* virtual */ void DrawRect(void *video, int width, int height, uint8 colour);
+ /* virtual */ void CopyFromBuffer(void *video, const void *src, int width, int height);
+ /* virtual */ void CopyToBuffer(const void *video, void *dst, int width, int height);
+ /* virtual */ void CopyImageToBuffer(const void *video, void *dst, int width, int height, int dst_pitch);
+ /* virtual */ void ScrollBuffer(void *video, int &left, int &top, int &width, int &height, int scroll_x, int scroll_y);
+ /* virtual */ int BufferSize(int width, int height);
+ /* virtual */ void PaletteAnimate(const Palette &palette);
+ /* virtual */ Blitter::PaletteAnimation UsePaletteAnimation();
+ /* virtual */ int GetBytesPerPixel() { return 2; }
+
+
+ /**
+ * Convert from rgb values to screen native 16bpp colour
+ */
+ static inline Colour16 To16(uint8 r, uint8 g, uint8 b)
+ {
+ return Colour16(r >> 3, g >> 2, b >> 3);
+ }
+
+ /**
+ * Convert from 32bpp colour to screen native 16bpp colour
+ */
+ static inline Colour16 To16(Colour c)
+ {
+ return To16(c.r, c.g, c.b);
+ }
+
+ /**
+ * Look up the colour in the current palette.
+ */
+ static inline Colour LookupColourInPalette32(uint index)
+ {
+ return _cur_palette.palette[index];
+ }
+
+ /**
+ * Look up the colour in the current palette.
+ */
+ static inline Colour16 LookupColourInPalette(uint index)
+ {
+ return To16(LookupColourInPalette32(index));
+ }
+
+ /**
+ * Compose a colour based on RGBA values and the current pixel value.
+ * @param r range is from 0 to 31.
+ * @param g range is from 0 to 63.
+ * @param b range is from 0 to 31.
+ * @param a range is from 0 to 15.
+ */
+ static inline Colour16 ComposeColourRGBANoCheck(uint8 r, uint8 g, uint8 b, uint8 a, Colour16 current)
+ {
+ /* The 16 is wrong, it should be 15, but 16 is much faster... */
+ return Colour16 ( ((int)(r - current.r) * a) / 16 + current.r,
+ ((int)(g - current.g) * a) / 16 + current.g,
+ ((int)(b - current.b) * a) / 16 + current.b );
+ }
+
+ /**
+ * Compose a colour based on RGBA values and the current pixel value.
+ * Handles fully transparent and solid pixels in a special (faster) way.
+ * @param r range is from 0 to 31.
+ * @param g range is from 0 to 63.
+ * @param b range is from 0 to 31.
+ * @param a range is from 0 to 15.
+ */
+ static inline Colour16 ComposeColourRGBA(uint8 r, uint8 g, uint8 b, uint8 a, Colour16 current)
+ {
+ if (a == 0) return current;
+ if (a >= 15) return Colour16(r, g, b);
+
+ return ComposeColourRGBANoCheck(r, g, b, a, current);
+ }
+
+ /**
+ * Compose a colour based on Pixel value, alpha value, and the current pixel value.
+ * @param a range is from 0 to 16.
+ */
+ static inline Colour16 ComposeColourPANoCheck(Colour16 colour, uint8 a, Colour16 current)
+ {
+ return ComposeColourRGBANoCheck(colour.r, colour.g, colour.b, a, current);
+ }
+
+ /**
+ * Compose a colour based on Pixel value, alpha value, and the current pixel value.
+ * Handles fully transparent and solid pixels in a special (faster) way.
+ * @param a range is from 0 to 15.
+ */
+ static inline Colour16 ComposeColourPA(Colour16 colour, uint8 a, Colour16 current)
+ {
+ if (a == 0) return current;
+ if (a >= 15) return colour;
+
+ return ComposeColourPANoCheck(colour, a, current);
+ }
+
+ /**
+ * Make a pixel looks like it is transparent.
+ * @param colour the colour already on the screen.
+ * @param nom the amount of transparency, nominator, makes colour lighter.
+ * @param denom denominator, makes colour darker.
+ * @return the new colour for the screen.
+ */
+ static inline Colour16 MakeTransparent(Colour16 colour, uint nom, uint denom = 256)
+ {
+ uint r = colour.r;
+ uint g = colour.g;
+ uint b = colour.b;
+
+ return Colour16( r * nom / denom,
+ g * nom / denom,
+ b * nom / denom );
+ }
+
+ /**
+ * Make a colour grey - based.
+ * @param colour the colour to make grey.
+ * @return the new colour, now grey.
+ */
+ static inline Colour16 MakeGrey(Colour16 colour)
+ {
+ uint r = colour.r;
+ uint g = colour.g;
+ uint b = colour.b;
+
+ /* To avoid doubles and stuff, multiple it with a total of 65536 (16bits), then
+ * divide by it to normalize the value to a byte again. See heightmap.cpp for
+ * information about the formula. */
+ uint grey = (((r << 3) * 19595) + ((g << 2) * 38470) + ((b << 3) * 7471)) / 65536;
+
+ return To16(grey, grey, grey);
+ }
+
+ enum { DEFAULT_BRIGHTNESS = 8 };
+
+ /**
+ * @param brightness range is from 0 to 15.
+ */
+ static inline Colour16 AdjustBrightness(Colour16 colour, uint8 brightness)
+ {
+ /* Shortcut for normal brightness */
+ if (brightness == DEFAULT_BRIGHTNESS) return colour;
+
+ uint16 ob = 0;
+ uint16 r = colour.r * brightness / DEFAULT_BRIGHTNESS;
+ uint16 g = colour.g * brightness / DEFAULT_BRIGHTNESS;
+ uint16 b = colour.b * brightness / DEFAULT_BRIGHTNESS;
+
+ /* Sum overbright */
+ if (r > 31) ob += r - 31;
+ if (g > 63) ob += g - 63;
+ if (b > 31) ob += b - 31;
+
+ if (ob == 0) return Colour16(r, g, b);
+
+ /* Reduce overbright strength */
+ ob /= 2;
+ return Colour16( r >= 31 ? 31 : min(r + ob * (31 - r) / 32, 31),
+ g >= 63 ? 63 : min(g + ob * (63 - g) / 64, 63),
+ b >= 31 ? 31 : min(b + ob * (31 - b) / 32, 31) );
+ }
+};
+
+#endif /* BLITTER_16BPP_BASE_HPP */
diff --git a/src/blitter/16bpp_simple.cpp b/src/blitter/16bpp_simple.cpp
new file mode 100644
index 0000000000..a3e1f4d0ed
--- /dev/null
+++ b/src/blitter/16bpp_simple.cpp
@@ -0,0 +1,146 @@
+/* $Id$ */
+
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD 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, version 2.
+ * OpenTTD 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 OpenTTD. If not, see .
+ */
+
+/** @file 32bpp_simple.cpp Implementation of the simple 32 bpp blitter. */
+
+#include "../stdafx.h"
+#include "../zoom_func.h"
+#include "16bpp_simple.hpp"
+#include "32bpp_base.hpp"
+
+#include "../table/sprites.h"
+
+#include
+
+/** Instantiation of the simple 16bpp blitter factory. */
+static FBlitter_16bppSimple iFBlitter_16bppSimple;
+
+void Blitter_16bppSimple::Draw(Blitter::BlitterParams *bp, BlitterMode mode, ZoomLevel zoom)
+{
+ const Pixel *src, *src_line;
+ Colour16 *dst, *dst_line;
+
+ /* Find where to start reading in the source sprite */
+ src_line = (const Pixel *)bp->sprite + (bp->skip_top * bp->sprite_width + bp->skip_left) * ScaleByZoom(1, zoom);
+ dst_line = (Colour16 *)bp->dst + bp->top * bp->pitch + bp->left;
+
+ for (int y = 0; y < bp->height; y++) {
+ dst = dst_line;
+ dst_line += bp->pitch;
+
+ src = src_line;
+ src_line += bp->sprite_width * ScaleByZoom(1, zoom);
+
+ for (int x = 0; x < bp->width; x++) {
+ switch (mode) {
+ case BM_COLOUR_REMAP:
+ /* In case the m-channel is zero, do not remap this pixel in any way */
+ if (src->m == 0) {
+ if (src->a != 0) *dst = ComposeColourPA(src->c, src->a, *dst);
+ } else {
+ if (bp->remap[src->m] != 0) *dst = ComposeColourPA(this->AdjustBrightness(this->LookupColourInPalette(bp->remap[src->m]), src->v), src->a, *dst);
+ }
+ break;
+
+ case BM_TRANSPARENT:
+ /* TODO -- We make an assumption here that the remap in fact is transparency, not some colour.
+ * This is never a problem with the code we produce, but newgrfs can make it fail... or at least:
+ * we produce a result the newgrf maker didn't expect ;) */
+
+ /* Make the current colour a bit more black, so it looks like this image is transparent */
+ if (src->a != 0) *dst = MakeTransparent(*dst, 192);
+ break;
+
+ default:
+ if (src->a != 0) *dst = ComposeColourPA(src->c, src->a, *dst);
+ break;
+ }
+ dst++;
+ src += ScaleByZoom(1, zoom);
+ }
+ }
+}
+
+void Blitter_16bppSimple::DrawColourMappingRect(void *dst, int width, int height, PaletteID pal)
+{
+ Colour16 *udst = (Colour16 *)dst;
+
+ if (pal == PALETTE_TO_TRANSPARENT) {
+ do {
+ for (int i = 0; i != width; i++) {
+ *udst = MakeTransparent(*udst, 154);
+ udst++;
+ }
+ udst = udst - width + _screen.pitch;
+ } while (--height);
+ return;
+ }
+ if (pal == PALETTE_NEWSPAPER) {
+ do {
+ for (int i = 0; i != width; i++) {
+ *udst = MakeGrey(*udst);
+ udst++;
+ }
+ udst = udst - width + _screen.pitch;
+ } while (--height);
+ return;
+ }
+
+ DEBUG(misc, 0, "16bpp blitter doesn't know how to draw this colour table ('%d')", pal);
+}
+
+Sprite *Blitter_16bppSimple::Encode(const SpriteLoader::Sprite *sprite, AllocatorProc *allocator)
+{
+ Pixel *dst;
+ Sprite *dest_sprite = (Sprite *)allocator(sizeof(*dest_sprite) + (size_t)sprite->height * (size_t)sprite->width * sizeof(Pixel));
+
+ dest_sprite->height = sprite->height;
+ dest_sprite->width = sprite->width;
+ dest_sprite->x_offs = sprite->x_offs;
+ dest_sprite->y_offs = sprite->y_offs;
+
+ dst = (Pixel *)dest_sprite->data;
+ SpriteLoader::CommonPixel *src = (SpriteLoader::CommonPixel *)sprite->data;
+
+ for (int i = 0; i < sprite->height * sprite->width; i++) {
+ if (src->m == 0) {
+ dst[i].c = To16(src->r, src->g, src->b);
+ dst[i].a = src->a / 16;
+ dst[i].m = 0;
+ dst[i].v = 0;
+ } else {
+ /* Get brightest value */
+ uint8 rgb_max = max(src->r, max(src->g, src->b));
+#if 0
+ /* Pre-convert the mapping channel to a RGB value,
+ use 32bpp AdjustBrightness() variant for better colors,
+ because this function is not called each frame */
+ if (rgb_max == 0) rgb_max = Blitter_32bppBase::DEFAULT_BRIGHTNESS;
+ dst[i].c = To16(Blitter_32bppBase::AdjustBrightness(this->LookupColourInPalette32(src->m), rgb_max));
+ dst[i].v = rgb_max / 16;
+#endif
+ rgb_max /= 16;
+
+ /* Black pixel (8bpp or old 16bpp image), so use default value */
+ if (rgb_max == 0) rgb_max = DEFAULT_BRIGHTNESS;
+
+ /* Pre-convert the mapping channel to a RGB value,
+ use 32bpp AdjustBrightness() variant for better colors,
+ because this function is not called each frame */
+ dst[i].c = AdjustBrightness(this->LookupColourInPalette(src->m), rgb_max);
+ dst[i].v = rgb_max;
+
+ dst[i].a = src->a / 16;
+ dst[i].m = src->m;
+ }
+ src++;
+ }
+
+ return dest_sprite;
+}
diff --git a/src/blitter/16bpp_simple.hpp b/src/blitter/16bpp_simple.hpp
new file mode 100644
index 0000000000..e708ce9a93
--- /dev/null
+++ b/src/blitter/16bpp_simple.hpp
@@ -0,0 +1,35 @@
+/* $Id$ */
+
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD 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, version 2.
+ * OpenTTD 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 OpenTTD. If not, see .
+ */
+
+/** @file 16bpp_simple.hpp Simple 16 bpp blitter. */
+
+#ifndef BLITTER_16BPP_SIMPLE_HPP
+#define BLITTER_16BPP_SIMPLE_HPP
+
+#include "16bpp_base.hpp"
+#include "factory.hpp"
+
+/** The most trivial 32 bpp blitter (without palette animation). */
+class Blitter_16bppSimple : public Blitter_16bppBase {
+public:
+ /* virtual */ void Draw(Blitter::BlitterParams *bp, BlitterMode mode, ZoomLevel zoom);
+ /* virtual */ void DrawColourMappingRect(void *dst, int width, int height, PaletteID pal);
+ /* virtual */ Sprite *Encode(const SpriteLoader::Sprite *sprite, AllocatorProc *allocator);
+
+ /* virtual */ const char *GetName() { return "16bpp-simple"; }
+};
+
+/** Factory for the simple 16 bpp blitter. */
+class FBlitter_16bppSimple : public BlitterFactory {
+public:
+ FBlitter_16bppSimple() : BlitterFactory("16bpp-simple", "16bpp Simple Blitter (no palette animation)") {}
+ /* virtual */ Blitter *CreateInstance() { return new Blitter_16bppSimple(); }
+};
+
+#endif /* BLITTER_32BPP_SIMPLE_HPP */