Merge lp:~widelands-dev/widelands/move_road_texture_out_of_graphics into lp:widelands

[SirVer]

A bunch of cleanups and clarifications. This contains https://code.launchpad.net/~widelands-dev/widelands/fix_some_resizing_bugs (the diff should be against this branch) and should not be merged before the other one is.

Suggested commit message:

- Removes a lot of dynamic_casts from Surface to Texture.
- Ownership of dither texture and road textures are now only with the respective OpenGL programs. This cleans up class Graphic.
- Renamed Texture to TerrainTexture - I expect this will go away soon too.
- Renamed GLSurfaceScreen to Screen.
- Renamed GLSurfaceTexture to Texture.
- Renamed SurfaceCache to TextureCache.
- Renamed Composite to BlendMode.

[Tino (tino79)]

Again: It does compile with mingw and a quick visual check revealed no graphical errors on my system.

[Tino (tino79)]

review: Approve

=== modified file 'src/editor/ui_menus/editor_tool_set_terrain_options_menu.cc'
--- src/editor/ui_menus/editor_tool_set_terrain_options_menu.cc	2014-11-02 20:31:40 +0000
+++ src/editor/ui_menus/editor_tool_set_terrain_options_menu.cc	2014-11-24 07:32:35 +0000
@@ -30,7 +30,7 @@
 #include "graphic/graphic.h"
 #include "graphic/in_memory_image.h"
 #include "graphic/rendertarget.h"
-#include "graphic/surface.h"
+#include "graphic/terrain_texture.h"
 #include "graphic/texture.h"
 #include "logic/map.h"
 #include "logic/world/editor_category.h"
@@ -77,50 +77,50 @@
 
 		const Image* tex = g_gr->images().get(
 		   g_gr->get_maptexture_data(terrain_descr.get_texture())->get_texture_image());
-		Surface* surf = Surface::create(tex->width(), tex->height());
-		surf->blit(Point(0, 0), tex->surface(), Rect(0, 0, tex->width(), tex->height()), CM_Copy);
+		Texture* texture = new Texture(tex->width(), tex->height());
+		texture->blit(Point(0, 0), tex->texture(), Rect(0, 0, tex->width(), tex->height()), BlendMode::Copy);
 		Point pt(1, tex->height() - kSmallPicHeight - 1);
 
 		if (ter_is == TerrainDescription::GREEN) {
-			surf->blit(pt, green->surface(), Rect(0, 0, green->width(), green->height()));
+			texture->blit(pt, green->texture(), Rect(0, 0, green->width(), green->height()));
 			pt.x += kSmallPicWidth + 1;
 			/** TRANSLATORS: This is a terrain type tooltip in the editor */
 			tooltips.push_back(_("arable"));
 		} else {
 			if (ter_is & TerrainDescription::WATER) {
-				surf->blit(pt, water->surface(), Rect(0, 0, water->width(), water->height()));
+				texture->blit(pt, water->texture(), Rect(0, 0, water->width(), water->height()));
 				pt.x += kSmallPicWidth + 1;
 				/** TRANSLATORS: This is a terrain type tooltip in the editor */
 				tooltips.push_back(_("aquatic"));
 			}
 			else if (ter_is & TerrainDescription::MOUNTAIN) {
-				surf->blit(pt, mountain->surface(), Rect(0, 0, mountain->width(), mountain->height()));
+				texture->blit(pt, mountain->texture(), Rect(0, 0, mountain->width(), mountain->height()));
 				pt.x += kSmallPicWidth + 1;
 				/** TRANSLATORS: This is a terrain type tooltip in the editor */
 				tooltips.push_back(_("mountainous"));
 			}
 			if (ter_is & TerrainDescription::ACID) {
-				surf->blit(pt, dead->surface(), Rect(0, 0, dead->width(), dead->height()));
+				texture->blit(pt, dead->texture(), Rect(0, 0, dead->width(), dead->height()));
 				pt.x += kSmallPicWidth + 1;
 				/** TRANSLATORS: This is a terrain type tooltip in the editor */
 				tooltips.push_back(_("dead"));
 			}
 			if (ter_is & TerrainDescription::UNPASSABLE) {
-				surf->blit(
-				   pt, unpassable->surface(), Rect(0, 0, unpassable->width(), unpassable->height()));
+				texture->blit(
+				   pt, unpassable->texture(), Rect(0, 0, unpassable->width(), unpassable->height()));
 				pt.x += kSmallPicWidth + 1;
 				/** TRANSLATORS: This is a terrain type tooltip in the editor */
 				tooltips.push_back(_("unpassable"));
 			}
 			if (ter_is & TerrainDescription::DRY) {
-				surf->blit(pt, dry->surface(), Rect(0, 0, dry->width(), dry->height()));
+				texture->blit(pt, dry->texture(), Rect(0, 0, dry->width(), dry->height()));
 				/** TRANSLATORS: This is a terrain type tooltip in the editor */
 				 tooltips.push_back(_("treeless"));
 			}
 		}
 
 		// Make sure we delete this later on.
-		offscreen_images->emplace_back(new_in_memory_image("dummy_hash", surf));
+		offscreen_images->emplace_back(new_in_memory_image("dummy_hash", texture));
 		break;
 	}
 	/** TRANSLATORS: %1% = terrain name, %2% = list of terrain types  */

=== modified file 'src/game_io/CMakeLists.txt'
--- src/game_io/CMakeLists.txt	2014-10-11 16:08:10 +0000
+++ src/game_io/CMakeLists.txt	2014-11-24 07:32:35 +0000
@@ -27,7 +27,6 @@
     base_time_string
     economy
     graphic
-    graphic_surface
     io_fileread
     io_filesystem
     logic

=== modified file 'src/game_io/game_preload_packet.cc'
--- src/game_io/game_preload_packet.cc	2014-11-01 18:24:28 +0000
+++ src/game_io/game_preload_packet.cc	2014-11-24 07:32:35 +0000
@@ -28,7 +28,6 @@
 #include "graphic/graphic.h"
 #include "graphic/in_memory_image.h"
 #include "graphic/minimap_renderer.h"
-#include "graphic/surface.h"
 #include "logic/game.h"
 #include "logic/game_data_error.h"
 #include "logic/map.h"

=== modified file 'src/graphic/CMakeLists.txt'
--- src/graphic/CMakeLists.txt	2014-11-23 10:13:14 +0000
+++ src/graphic/CMakeLists.txt	2014-11-24 07:32:35 +0000
@@ -45,17 +45,17 @@
 
 wl_library(graphic_surface
   SRCS
-    compositemode.h
-    gl/surface_screen.cc
-    gl/surface_screen.h
-    gl/surface_texture.cc
-    gl/surface_texture.h
+    blend_mode.h
     gl/utils.cc
     gl/utils.h
+    screen.cc
+    screen.h
     surface.cc
     surface.h
-    surface_cache.cc
-    surface_cache.h
+    texture.cc
+    texture.h
+    texture_cache.cc
+    texture_cache.h
   USES_OPENGL
   USES_SDL2
   DEPENDS
@@ -90,20 +90,20 @@
     gl/blit_program.h
     gl/dither_program.cc
     gl/dither_program.h
+    gl/draw_line_program.cc
+    gl/draw_line_program.h
     gl/draw_rect_program.cc
     gl/draw_rect_program.h
-    gl/draw_line_program.cc
-    gl/draw_line_program.h
+    gl/fields_to_draw.h
     gl/fill_rect_program.cc
     gl/fill_rect_program.h
-    gl/fields_to_draw.h
     gl/game_renderer.cc
     gl/game_renderer.h
     gl/road_program.cc
     gl/road_program.h
+    gl/system_headers.h
     gl/terrain_program.cc
     gl/terrain_program.h
-    gl/system_headers.h
     graphic.cc
     graphic.h
     image_transformations.cc
@@ -116,10 +116,10 @@
     rendertarget.h
     richtext.cc
     richtext.h
+    terrain_texture.cc
+    terrain_texture.h
     text_parser.cc
     text_parser.h
-    texture.cc
-    texture.h
     wordwrap.cc
     wordwrap.h
   USES_OPENGL
@@ -146,6 +146,7 @@
     io_filesystem
     io_stream
     logic
+    notifications
     profile
     scripting
     sound

=== modified file 'src/graphic/animation.cc'
--- src/graphic/animation.cc	2014-09-20 09:37:47 +0000
+++ src/graphic/animation.cc	2014-11-24 07:32:35 +0000
@@ -41,7 +41,7 @@
 #include "graphic/image_cache.h"
 #include "graphic/image_transformations.h"
 #include "graphic/surface.h"
-#include "graphic/surface_cache.h"
+#include "graphic/texture_cache.h"
 #include "io/filesystem/layered_filesystem.h"
 #include "logic/bob.h"
 #include "logic/instances.h"
@@ -324,7 +324,7 @@
 	assert(target);
 
 	const Image& frame = get_frame(time, clr);
-	target->blit(dst, frame.surface(), srcrc);
+	target->blit(dst, frame.texture(), srcrc);
 }
 
 const Image& NonPackedAnimation::get_frame(uint32_t time, const RGBColor* playercolor) const {

=== renamed file 'src/graphic/compositemode.h' => 'src/graphic/blend_mode.h'
--- src/graphic/compositemode.h	2014-11-02 14:11:52 +0000
+++ src/graphic/blend_mode.h	2014-11-24 07:32:35 +0000
@@ -17,23 +17,17 @@
  *
  */
 
-#ifndef WL_GRAPHIC_COMPOSITEMODE_H
-#define WL_GRAPHIC_COMPOSITEMODE_H
-
-/**
- * Defines composition operations performed while blitting.
- */
-enum Composite {
-	/**
-	 * Perform a normal blitting operation that respects the alpha
-	 * channel if present.
-	 */
-	CM_UseAlpha = 0,
-
-	/**
-	 * Copy all pixel information, including alpha channel information.
-	 */
-	CM_Copy
+#ifndef WL_GRAPHIC_BLEND_MODE_H
+#define WL_GRAPHIC_BLEND_MODE_H
+
+// Defines blending during blitting.
+enum BlendMode {
+	// Perform a normal blitting operation that respects the alpha channel if
+	// present.
+	UseAlpha = 0,
+
+	// Copy all pixel information, including alpha channel information.
+	Copy
 };
 
-#endif  // end of include guard: WL_GRAPHIC_COMPOSITEMODE_H
+#endif  // end of include guard: WL_GRAPHIC_BLEND_MODE_H

=== modified file 'src/graphic/font_handler.cc'
--- src/graphic/font_handler.cc	2014-10-14 06:30:20 +0000
+++ src/graphic/font_handler.cc	2014-11-24 07:32:35 +0000
@@ -31,7 +31,7 @@
 #include "graphic/graphic.h"
 #include "graphic/in_memory_image.h"
 #include "graphic/rendertarget.h"
-#include "graphic/surface.h"
+#include "graphic/texture.h"
 #include "graphic/wordwrap.h"
 
 namespace UI {
@@ -197,7 +197,7 @@
 		return;
 	}
 
-	lce.image = new_in_memory_image("dummy_hash", Surface::create(text_surface));
+	lce.image = new_in_memory_image("dummy_hash", new Texture(text_surface));
 	lce.width = lce.image->width();
 	lce.height = lce.image->height();
 }

=== modified file 'src/graphic/font_handler1.cc'
--- src/graphic/font_handler1.cc	2014-09-10 14:48:40 +0000
+++ src/graphic/font_handler1.cc	2014-11-24 07:32:35 +0000
@@ -29,11 +29,11 @@
 #include "graphic/image.h"
 #include "graphic/image_cache.h"
 #include "graphic/rendertarget.h"
-#include "graphic/surface.h"
-#include "graphic/surface_cache.h"
 #include "graphic/text/rt_errors.h"
 #include "graphic/text/rt_render.h"
 #include "graphic/text/sdl_ttf_font.h"
+#include "graphic/texture.h"
+#include "graphic/texture_cache.h"
 #include "io/filesystem/filesystem.h"
 
 
@@ -42,29 +42,29 @@
 
 namespace {
 
-// An Image implementation that recreates a rich text surface when needed on
+// An Image implementation that recreates a rich text texture when needed on
 // the fly. It is meant to be saved into the ImageCache.
 class RTImage : public Image {
 public:
 	RTImage
-		(const string& ghash, SurfaceCache* surface_cache, RT::Renderer*
+		(const string& ghash, TextureCache* texture_cache, RT::Renderer*
 		 rt_renderer, const string& text, uint16_t gwidth)
-		: hash_(ghash), text_(text), width_(gwidth), surface_cache_(surface_cache),
+		: hash_(ghash), text_(text), width_(gwidth), texture_cache_(texture_cache),
 		  rt_renderer_(rt_renderer)
 	{}
 	virtual ~RTImage() {}
 
 	// Implements Image.
-	uint16_t width() const override {return surface()->width();}
-	uint16_t height() const override {return surface()->height();}
+	uint16_t width() const override {return texture()->width();}
+	uint16_t height() const override {return texture()->height();}
 	const string& hash() const override {return hash_;}
-	Surface* surface() const override {
-		Surface* surf = surface_cache_->get(hash_);
+	Texture* texture() const override {
+		Texture* surf = texture_cache_->get(hash_);
 		if (surf)
 			return surf;
 
 		surf = rt_renderer_->render(text_, width_);
-		surface_cache_->insert(hash_, surf, true);
+		texture_cache_->insert(hash_, surf, true);
 		return surf;
 	}
 
@@ -74,7 +74,7 @@
 	uint16_t width_;
 
 	// Nothing owned.
-	SurfaceCache* const surface_cache_;
+	TextureCache* const texture_cache_;
 	RT::Renderer* const rt_renderer_;
 };
 
@@ -87,8 +87,8 @@
 // be a problem.
 class FontHandler1 : public IFontHandler1 {
 public:
-	FontHandler1(ImageCache* image_cache, SurfaceCache* surface_cache, RT::Renderer* renderer) :
-		surface_cache_(surface_cache), image_cache_(image_cache), renderer_(renderer) {}
+	FontHandler1(ImageCache* image_cache, TextureCache* texture_cache, RT::Renderer* renderer) :
+		texture_cache_(texture_cache), image_cache_(image_cache), renderer_(renderer) {}
 	virtual ~FontHandler1() {}
 
 	const Image* render(const string& text, uint16_t w = 0) override {
@@ -97,21 +97,21 @@
 		if (image_cache_->has(hash))
 			return image_cache_->get(hash);
 
-		std::unique_ptr<RTImage> image(new RTImage(hash, surface_cache_, renderer_.get(), text, w));
-		image->surface(); // force the rich text to get rendered in case there is an exception thrown.
+		std::unique_ptr<RTImage> image(new RTImage(hash, texture_cache_, renderer_.get(), text, w));
+		image->texture(); // force the rich text to get rendered in case there is an exception thrown.
 
 		return image_cache_->insert(image.release());
 	}
 
 private:
-	SurfaceCache* const surface_cache_;  // not owned
+	TextureCache* const texture_cache_;  // not owned
 	ImageCache* const image_cache_;  // not owned
 	std::unique_ptr<RT::Renderer> renderer_;
 };
 
 IFontHandler1 * create_fonthandler(Graphic* gr) {
 	return new FontHandler1(
-	   &gr->images(), &gr->surfaces(), new RT::Renderer(&gr->images(), &gr->surfaces()));
+	   &gr->images(), &gr->textures(), new RT::Renderer(&gr->images(), &gr->textures()));
 }
 
 IFontHandler1 * g_fh1 = nullptr;

=== modified file 'src/graphic/gl/blit_program.cc'
--- src/graphic/gl/blit_program.cc	2014-11-02 16:55:53 +0000
+++ src/graphic/gl/blit_program.cc	2014-11-24 07:32:35 +0000
@@ -97,7 +97,7 @@
 void BlitProgram::draw(const FloatRect& gl_dest_rect,
                        const FloatRect& gl_src_rect,
                        const GLuint gl_texture,
-                       const Composite composite) {
+                       const BlendMode blend_mode) {
 	glUseProgram(gl_program_.object());
 	glEnableVertexAttribArray(attr_position_);
 	glBindBuffer(GL_ARRAY_BUFFER, gl_array_buffer_.object());
@@ -117,13 +117,13 @@
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, gl_texture);
 
-	if (composite == CM_Copy) {
+	if (blend_mode == BlendMode::Copy) {
 		glBlendFunc(GL_ONE, GL_ZERO);
 	}
 
 	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
-	if (composite == CM_Copy) {
+	if (blend_mode == BlendMode::Copy) {
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	}
 

=== modified file 'src/graphic/gl/blit_program.h'
--- src/graphic/gl/blit_program.h	2014-11-08 18:06:17 +0000
+++ src/graphic/gl/blit_program.h	2014-11-24 07:32:35 +0000
@@ -21,8 +21,8 @@
 #define WL_GRAPHIC_GL_BLIT_PROGRAM_H
 
 #include "base/rect.h"
+#include "graphic/blend_mode.h"
 #include "graphic/color.h"
-#include "graphic/gl/surface_texture.h"
 #include "graphic/gl/utils.h"
 
 class BlitProgram {
@@ -32,12 +32,12 @@
 
 	// Draws the rectangle 'gl_src_rect' from the texture with the name
 	// 'gl_texture' to 'gl_dest_rect' in the currently bound framebuffer. All
-	// coordinates are in the OpenGL frame. The 'composite' defines if the
+	// coordinates are in the OpenGL frame. The 'blend_mode' defines if the
 	// values are copied or if alpha values are used.
 	void draw(const FloatRect& gl_dest_rect,
 	          const FloatRect& gl_src_rect,
 	          const GLuint gl_texture,
-	          const Composite composite);
+	          const BlendMode blend_mode);
 
 private:
 	BlitProgram();

=== modified file 'src/graphic/gl/dither_program.cc'
--- src/graphic/gl/dither_program.cc	2014-11-08 18:06:17 +0000
+++ src/graphic/gl/dither_program.cc	2014-11-24 07:32:35 +0000
@@ -21,10 +21,9 @@
 
 #include "base/wexception.h"
 #include "graphic/gl/fields_to_draw.h"
-#include "graphic/gl/surface_texture.h"
 #include "graphic/graphic.h"
 #include "graphic/image_io.h"
-#include "graphic/surface_cache.h"
+#include "graphic/terrain_texture.h"
 #include "graphic/texture.h"
 #include "io/fileread.h"
 #include "io/filesystem/layered_filesystem.h"
@@ -73,19 +72,6 @@
 }
 )";
 
-// Returns the texture mask for the dithering step.
-const GLSurfaceTexture* get_dither_edge_texture() {
-	constexpr char kFilename[] = "world/pics/edge.png";
-	constexpr char kCacheName[] =  "gltex#world/pics/edge.png";
-
-	if (Surface* surface = g_gr->surfaces().get(kCacheName))
-		return dynamic_cast<GLSurfaceTexture*>(surface);
-
-	SDL_Surface* sdlsurf = load_image_as_sdl_surface(kFilename, g_fs);
-	GLSurfaceTexture* edgetexture = new GLSurfaceTexture(sdlsurf, true);
-	g_gr->surfaces().insert(kCacheName, edgetexture, false);
-	return edgetexture;
-}
 
 }  // namespace
 
@@ -101,8 +87,13 @@
 
 	u_dither_texture_ = glGetUniformLocation(gl_program_.object(), "u_dither_texture");
 	u_terrain_texture_ = glGetUniformLocation(gl_program_.object(), "u_terrain_texture");
+
+	SDL_Surface* sdlsurf = load_image_as_sdl_surface("world/pics/edge.png", g_fs);
+	dither_mask_.reset(new Texture(sdlsurf, true));
 }
 
+DitherProgram::~DitherProgram() {}
+
 void DitherProgram::add_vertex(const FieldsToDraw::Field& field,
                                const int order_index,
                                const int terrain) {
@@ -220,7 +211,7 @@
 	// Set the sampler texture unit to 0
 	glActiveTexture(GL_TEXTURE0);
 	glUniform1i(u_dither_texture_, 0);
-	glBindTexture(GL_TEXTURE_2D, get_dither_edge_texture()->get_gl_texture());
+	glBindTexture(GL_TEXTURE_2D, dither_mask_->get_gl_texture());
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
@@ -234,9 +225,10 @@
 		if (current_data.empty()) {
 			continue;
 		}
-		glBindTexture(
-		   GL_TEXTURE_2D,
-		   g_gr->get_maptexture_data(terrains.get_unmutable(i).get_texture())->get_texture());
+		glBindTexture(GL_TEXTURE_2D,
+		              g_gr->get_maptexture_data(terrains.get_unmutable(i).get_texture())
+		                 ->texture()
+		                 .get_gl_texture());
 
 		glBufferData(GL_ARRAY_BUFFER,
 		             sizeof(PerVertexData) * current_data.size(),

=== modified file 'src/graphic/gl/dither_program.h'
--- src/graphic/gl/dither_program.h	2014-11-08 18:06:17 +0000
+++ src/graphic/gl/dither_program.h	2014-11-24 07:32:35 +0000
@@ -20,14 +20,19 @@
 #ifndef WL_GRAPHIC_GL_DITHER_PROGRAM_H
 #define WL_GRAPHIC_GL_DITHER_PROGRAM_H
 
+#include <memory>
+
 #include "graphic/gl/fields_to_draw.h"
 #include "graphic/gl/utils.h"
 #include "logic/description_maintainer.h"
 #include "logic/world/terrain_description.h"
 
+class Texture;
+
 class DitherProgram {
 public:
 	DitherProgram();
+	~DitherProgram();
 
 	// Draws the terrain.
 	void draw(const DescriptionMaintainer<Widelands::TerrainDescription>& terrains,
@@ -77,6 +82,9 @@
 	GLint u_terrain_texture_;
 	GLint u_dither_texture_;
 
+	// The texture mask for the dithering step.
+	std::unique_ptr<Texture> dither_mask_;
+
 	// Objects below are here to avoid memory allocations on each frame, they
 	// could theoretically also always be recreated. Index as follows:
 	// vertices_[terrain_index][vertex_index]

=== modified file 'src/graphic/gl/game_renderer.cc'
--- src/graphic/gl/game_renderer.cc	2014-11-22 21:31:21 +0000
+++ src/graphic/gl/game_renderer.cc	2014-11-24 07:32:35 +0000
@@ -28,7 +28,7 @@
 #include "graphic/graphic.h"
 #include "graphic/rendertarget.h"
 #include "graphic/surface.h"
-#include "graphic/texture.h"
+#include "graphic/terrain_texture.h"
 #include "logic/editor_game_base.h"
 #include "logic/player.h"
 #include "logic/world/world.h"
@@ -165,8 +165,8 @@
 			map.normalize_coords(coords);
 			const FCoords& fcoords = map.get_fcoords(coords);
 
-			f.texture_x = float(x) / TEXTURE_WIDTH;
-			f.texture_y = float(y) / TEXTURE_HEIGHT;
+			f.texture_x = float(x) / kTextureWidth;
+			f.texture_y = float(y) / kTextureHeight;
 
 			f.gl_x = f.pixel_x = x + surface_offset.x;
 			f.gl_y = f.pixel_y = y + surface_offset.y - fcoords.field->get_height() * HEIGHT_FACTOR;

=== modified file 'src/graphic/gl/road_program.cc'
--- src/graphic/gl/road_program.cc	2014-11-22 21:31:21 +0000
+++ src/graphic/gl/road_program.cc	2014-11-24 07:32:35 +0000
@@ -24,6 +24,7 @@
 #include "base/log.h"
 #include "graphic/gl/fields_to_draw.h"
 #include "graphic/graphic.h"
+#include "graphic/image_io.h"
 #include "graphic/texture.h"
 #include "logic/roadtype.h"
 
@@ -85,6 +86,12 @@
 
 	u_normal_road_texture_ = glGetUniformLocation(gl_program_.object(), "u_normal_road_texture");
 	u_busy_road_texture_ = glGetUniformLocation(gl_program_.object(), "u_busy_road_texture");
+
+	normal_road_texture_.reset(load_image("world/pics/roadt_normal.png"));
+	busy_road_texture_.reset(load_image("world/pics/roadt_busy.png"));
+}
+
+RoadProgram::~RoadProgram() {
 }
 
 void RoadProgram::add_road(const Surface& surface,
@@ -211,17 +218,12 @@
 	glBindBuffer(GL_ARRAY_BUFFER, 0);
 
 	// Bind the textures.
-	const GLuint rt_normal = dynamic_cast<const GLSurfaceTexture&>(
-	                      g_gr->get_road_texture(Widelands::Road_Normal)).get_gl_texture();
-	const GLuint rt_busy = dynamic_cast<const GLSurfaceTexture&>(
-	                    g_gr->get_road_texture(Widelands::Road_Busy)).get_gl_texture();
-
 	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, rt_normal);
+	glBindTexture(GL_TEXTURE_2D, normal_road_texture_->get_gl_texture());
 	glUniform1i(u_normal_road_texture_, 0);
 
 	glActiveTexture(GL_TEXTURE1);
-	glBindTexture(GL_TEXTURE_2D, rt_busy);
+	glBindTexture(GL_TEXTURE_2D, busy_road_texture_->get_gl_texture());
 	glUniform1i(u_busy_road_texture_, 1);
 
 	glDrawArrays(GL_TRIANGLES, 0, vertices_.size());

=== modified file 'src/graphic/gl/road_program.h'
--- src/graphic/gl/road_program.h	2014-11-22 21:31:21 +0000
+++ src/graphic/gl/road_program.h	2014-11-24 07:32:35 +0000
@@ -20,18 +20,22 @@
 #ifndef WL_GRAPHIC_GL_ROAD_PROGRAM_H
 #define WL_GRAPHIC_GL_ROAD_PROGRAM_H
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "graphic/gl/fields_to_draw.h"
 #include "graphic/gl/utils.h"
-#include "graphic/surface.h"
 #include "logic/roadtype.h"
 
+class Texture;
+class Surface;
+
 class RoadProgram {
 public:
 	// Compiles the program. Throws on error.
 	RoadProgram();
+	~RoadProgram();
 
 	// Draws the roads. The 'surface' is needed to convert from pixel space to
 	// GL space.
@@ -79,6 +83,10 @@
 	// All vertices that get rendered this frame.
 	std::vector<PerVertexData> vertices_;
 
+	// The road textures.
+	std::unique_ptr<Texture> normal_road_texture_;
+	std::unique_ptr<Texture> busy_road_texture_;
+
 	DISALLOW_COPY_AND_ASSIGN(RoadProgram);
 };
 

=== modified file 'src/graphic/gl/terrain_program.cc'
--- src/graphic/gl/terrain_program.cc	2014-11-08 18:06:17 +0000
+++ src/graphic/gl/terrain_program.cc	2014-11-24 07:32:35 +0000
@@ -21,6 +21,7 @@
 
 #include "graphic/gl/fields_to_draw.h"
 #include "graphic/graphic.h"
+#include "graphic/terrain_texture.h"
 #include "graphic/texture.h"
 
 namespace  {
@@ -117,9 +118,10 @@
 		if (indices.empty()) {
 			continue;
 		}
-		glBindTexture(
-		   GL_TEXTURE_2D,
-		   g_gr->get_maptexture_data(terrains.get_unmutable(i).get_texture())->get_texture());
+		glBindTexture(GL_TEXTURE_2D,
+		              g_gr->get_maptexture_data(terrains.get_unmutable(i).get_texture())
+		                 ->texture()
+		                 .get_gl_texture());
 		glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT, indices.data());
 	}
 

=== modified file 'src/graphic/graphic.cc'
--- src/graphic/graphic.cc	2014-11-24 07:32:34 +0000
+++ src/graphic/graphic.cc	2014-11-24 07:32:35 +0000
@@ -35,13 +35,15 @@
 #include "graphic/animation.h"
 #include "graphic/diranimations.h"
 #include "graphic/font_handler.h"
-#include "graphic/gl/surface_screen.h"
+#include "graphic/gl/system_headers.h"
 #include "graphic/image.h"
 #include "graphic/image_io.h"
 #include "graphic/image_transformations.h"
 #include "graphic/rendertarget.h"
-#include "graphic/surface_cache.h"
+#include "graphic/screen.h"
+#include "graphic/terrain_texture.h"
 #include "graphic/texture.h"
+#include "graphic/texture_cache.h"
 #include "io/fileread.h"
 #include "io/filesystem/layered_filesystem.h"
 #include "io/streamwrite.h"
@@ -57,7 +59,7 @@
 
 /// The size of the transient (i.e. temporary) surfaces in the cache in bytes.
 /// These are all surfaces that are not loaded from disk.
-const uint32_t TRANSIENT_SURFACE_CACHE_SIZE = 160 << 20;   // shifting converts to MB
+const uint32_t TRANSIENT_TEXTURE_CACHE_SIZE = 160 << 20;   // shifting converts to MB
 
 // Sets the icon for the application.
 void set_icon(SDL_Window* sdl_window) {
@@ -80,8 +82,8 @@
    : m_window_mode_width(window_mode_w),
      m_window_mode_height(window_mode_h),
      m_update(true),
-     surface_cache_(create_surface_cache(TRANSIENT_SURFACE_CACHE_SIZE)),
-     image_cache_(new ImageCache(surface_cache_.get())),
+     texture_cache_(create_texture_cache(TRANSIENT_TEXTURE_CACHE_SIZE)),
+     image_cache_(new ImageCache(texture_cache_.get())),
      animation_manager_(new AnimationManager())
 {
 	ImageTransformations::initialize();
@@ -156,15 +158,12 @@
 		    disp_mode.h);
 		assert(SDL_BYTESPERPIXEL(disp_mode.format) == 4);
 	}
-
-	pic_road_normal_.reset(load_image("world/pics/roadt_normal.png"));
-	pic_road_busy_.reset(load_image("world/pics/roadt_busy.png"));
 }
 
 Graphic::~Graphic()
 {
 	m_maptextures.clear();
-	surface_cache_->flush();
+	texture_cache_->flush();
 	// TODO(unknown): this should really not be needed, but currently is :(
 	if (UI::g_fh)
 		UI::g_fh->flush();
@@ -209,7 +208,7 @@
 	int new_w, new_h;
 	SDL_GetWindowSize(m_sdl_window, &new_w, &new_h);
 
-	screen_.reset(new GLSurfaceScreen(new_w, new_h));
+	screen_.reset(new Screen(new_w, new_h));
 	m_rendertarget.reset(new RenderTarget(screen_.get()));
 
 	Notifications::publish(GraphicResolutionChanged{new_w, new_h});
@@ -301,12 +300,12 @@
  * @param sw a StreamWrite where the png is written to
  */
 void Graphic::save_png(const Image* image, StreamWrite * sw) const {
-	save_surface_to_png(image->surface(), sw);
+	save_surface_to_png(image->texture(), sw);
 }
 
 uint32_t Graphic::new_maptexture(const std::vector<std::string>& texture_files, const uint32_t frametime)
 {
-	m_maptextures.emplace_back(new Texture(texture_files, frametime));
+	m_maptextures.emplace_back(new TerrainTexture(texture_files, frametime));
 	return m_maptextures.size(); // ID 1 is at m_maptextures[0]
 }
 
@@ -335,20 +334,10 @@
  * Retrieve the map texture with the given number
  * \return the actual texture data associated with the given ID.
  */
-Texture * Graphic::get_maptexture_data(uint32_t id)
+TerrainTexture * Graphic::get_maptexture_data(uint32_t id)
 {
 	--id; // ID 1 is at m_maptextures[0]
 
 	assert(id < m_maptextures.size());
 	return m_maptextures[id].get();
 }
-
-/**
- * Retrives the texture of the road type.
- * \return The road texture
- */
-Surface& Graphic::get_road_texture(int32_t roadtex)
-{
-	return
-		roadtex == Widelands::Road_Normal ? *pic_road_normal_.get() : *pic_road_busy_.get();
-}

=== modified file 'src/graphic/graphic.h'
--- src/graphic/graphic.h	2014-11-24 07:32:34 +0000
+++ src/graphic/graphic.h	2014-11-24 07:32:35 +0000
@@ -36,9 +36,9 @@
 class AnimationManager;
 class RenderTarget;
 class Surface;
-class SurfaceCache;
+class TextureCache;
 class StreamWrite;
-struct Texture;
+struct TerrainTexture;
 
 // Will be send whenever the resolution changes.
 struct GraphicResolutionChanged {
@@ -50,10 +50,10 @@
 };
 
 /**
- * This class is a kind of Swiss Army knife for your graphics need. It
- * initializes the graphic system and provides access to resolutions. It has an
- * Animation, Image and Surface cache and owns the road textures. It also
- * offers functionality to save a screenshot.
+ * This class is a kind of Swiss Army knife for your graphics need.
+ * It initializes the graphic system and provides access to
+ * resolutions. It owns an Animation, Image and Surface cache. It
+ * also offers functionality to save a screenshot.
  */
 class Graphic {
 public:
@@ -77,21 +77,19 @@
 	void refresh();
 	SDL_Window* get_sdlwindow() {return m_sdl_window;}
 
-	SurfaceCache& surfaces() const {return *surface_cache_.get();}
+	TextureCache& textures() const {return *texture_cache_.get();}
 	ImageCache& images() const {return *image_cache_.get();}
 	AnimationManager& animations() const {return *animation_manager_.get();}
 
 	void save_png(const Image*, StreamWrite*) const;
 
-	// Creates a new Texture() with the given 'frametime' and using the given
+	// Creates a new TerrainTexture() with the given 'frametime' and using the given
 	// 'texture_files' as the images for it and returns it id.
 	uint32_t new_maptexture(const std::vector<std::string>& texture_files, uint32_t frametime);
 	void animate_maptextures(uint32_t time);
 
 	void screenshot(const std::string& fname) const;
-	Texture * get_maptexture_data(uint32_t id);
-
-	Surface& get_road_texture(int32_t roadtex);
+	TerrainTexture * get_maptexture_data(uint32_t id);
 
 private:
 	// Called when the resolution (might) have changed.
@@ -114,19 +112,15 @@
 	/// This marks the complete screen for updating.
 	bool m_update;
 
-	/// Volatile cache of Hardware dependant surfaces.
-	std::unique_ptr<SurfaceCache> surface_cache_;
+	/// Volatile cache of Hardware dependant textures.
+	std::unique_ptr<TextureCache> texture_cache_;
 	/// Non-volatile cache of hardware independent images. The use the
-	/// surface_cache_ to cache their pixel data.
+	/// texture_cache_ to cache their pixel data.
 	std::unique_ptr<ImageCache> image_cache_;
 	/// This holds all animations.
 	std::unique_ptr<AnimationManager> animation_manager_;
 
-	// The texture needed to draw roads.
-	std::unique_ptr<Surface> pic_road_normal_;
-	std::unique_ptr<Surface> pic_road_busy_;
-
-	std::vector<std::unique_ptr<Texture>> m_maptextures;
+	std::vector<std::unique_ptr<TerrainTexture>> m_maptextures;
 };
 
 extern Graphic * g_gr;

=== modified file 'src/graphic/image.h'
--- src/graphic/image.h	2014-07-14 19:48:07 +0000
+++ src/graphic/image.h	2014-11-24 07:32:35 +0000
@@ -26,12 +26,12 @@
 
 #include "base/macros.h"
 
+class Texture;
+
 /**
  * Interface to a bitmap that can act as the source of a rendering
  * operation.
  */
-class Surface;
-
 class Image {
 public:
 	Image() = default;
@@ -41,7 +41,7 @@
 	virtual uint16_t height() const = 0;
 
 	// Internal functions needed for caching.
-	virtual Surface* surface() const = 0;
+	virtual Texture* texture() const = 0;
 	virtual const std::string& hash() const = 0;
 
 	DISALLOW_COPY_AND_ASSIGN(Image);

=== modified file 'src/graphic/image_cache.cc'
--- src/graphic/image_cache.cc	2014-07-26 10:43:23 +0000
+++ src/graphic/image_cache.cc	2014-11-24 07:32:35 +0000
@@ -25,21 +25,21 @@
 #include "base/log.h"
 #include "graphic/image.h"
 #include "graphic/image_io.h"
-#include "graphic/surface.h"
-#include "graphic/surface_cache.h"
+#include "graphic/texture.h"
+#include "graphic/texture_cache.h"
 
 namespace  {
 
 // Image Implementation that loads images from disc when they should be drawn.
-// Uses SurfaceCache. These images are meant to be cached in ImageCache.
+// Uses TextureCache. These images are meant to be cached in ImageCache.
 class FromDiskImage : public Image {
 public:
-	FromDiskImage(const std::string& filename, SurfaceCache* surface_cache) :
+	FromDiskImage(const std::string& filename, TextureCache* texture_cache) :
 		filename_(filename),
-		surface_cache_(surface_cache) {
-			Surface* surf = reload_image_();
-			w_ = surf->width();
-			h_ = surf->height();
+		texture_cache_(texture_cache) {
+			Texture* texture = reload_image_();
+			w_ = texture->width();
+			h_ = texture->height();
 		}
 	virtual ~FromDiskImage() {}
 
@@ -47,27 +47,27 @@
 	uint16_t width() const override {return w_; }
 	uint16_t height() const override {return h_;}
 	const std::string& hash() const override {return filename_;}
-	Surface* surface() const override {
-		Surface* surf = surface_cache_->get(filename_);
-		if (surf)
-			return surf;
+	Texture* texture() const override {
+		Texture* texture = texture_cache_->get(filename_);
+		if (texture)
+			return texture;
 		return reload_image_();
 	}
 
 private:
-	Surface* reload_image_() const {
-		Surface* surf = surface_cache_->insert(filename_, load_image(filename_), false);
-		return surf;
+	Texture* reload_image_() const {
+		Texture* texture = texture_cache_->insert(filename_, load_image(filename_), false);
+		return texture;
 	}
 	uint16_t w_, h_;
 	const std::string filename_;
 
-	SurfaceCache* const surface_cache_;  // Not owned.
+	TextureCache* const texture_cache_;  // Not owned.
 };
 
 }  // namespace
 
-ImageCache::ImageCache(SurfaceCache* const surface_cache) : surface_cache_(surface_cache) {
+ImageCache::ImageCache(TextureCache* const texture_cache) : texture_cache_(texture_cache) {
 }
 
 ImageCache::~ImageCache() {
@@ -90,7 +90,7 @@
 const Image* ImageCache::get(const std::string& hash) {
 	ImageMap::const_iterator it = images_.find(hash);
 	if (it == images_.end()) {
-		images_.insert(make_pair(hash, new FromDiskImage(hash, surface_cache_)));
+		images_.insert(make_pair(hash, new FromDiskImage(hash, texture_cache_)));
 		return get(hash);
 	}
 	return it->second;

=== modified file 'src/graphic/image_cache.h'
--- src/graphic/image_cache.h	2014-09-14 11:31:58 +0000
+++ src/graphic/image_cache.h	2014-11-24 07:32:35 +0000
@@ -28,7 +28,7 @@
 #include "base/macros.h"
 #include "graphic/image.h"
 
-class SurfaceCache;
+class TextureCache;
 
 // For historic reasons, most part of the Widelands code base expect that an
 // Image stays valid for the whole duration of the program run. This class is
@@ -40,7 +40,7 @@
 class ImageCache {
 public:
 	// Does not take ownership.
-	ImageCache(SurfaceCache* surface_cache);
+	ImageCache(TextureCache* texture_cache);
 	~ImageCache();
 
 	// Insert the given Image into the cache. The hash is defined by Image's hash()
@@ -60,7 +60,7 @@
 	using ImageMap = std::map<std::string, const Image*>;
 
 	ImageMap images_;  /// hash of cached filename/image pairs
-	SurfaceCache* const surface_cache_;  // Not owned.
+	TextureCache* const texture_cache_;  // Not owned.
 
 	DISALLOW_COPY_AND_ASSIGN(ImageCache);
 };

=== modified file 'src/graphic/image_io.cc'
--- src/graphic/image_io.cc	2014-09-20 09:37:47 +0000
+++ src/graphic/image_io.cc	2014-11-24 07:32:35 +0000
@@ -26,7 +26,7 @@
 #include <png.h>
 
 #include "base/wexception.h"
-#include "graphic/surface.h"
+#include "graphic/texture.h"
 #include "io/fileread.h"
 #include "io/filesystem/layered_filesystem.h"
 #include "io/streamwrite.h"
@@ -47,8 +47,8 @@
 
 }  // namespace
 
-Surface* load_image(const std::string& fname, FileSystem* fs) {
-	return Surface::create(load_image_as_sdl_surface(fname, fs));
+Texture* load_image(const std::string& fname, FileSystem* fs) {
+	return new Texture(load_image_as_sdl_surface(fname, fs));
 }
 
 SDL_Surface* load_image_as_sdl_surface(const std::string& fname, FileSystem* fs) {

=== modified file 'src/graphic/image_io.h'
--- src/graphic/image_io.h	2014-09-09 17:15:20 +0000
+++ src/graphic/image_io.h	2014-11-24 07:32:35 +0000
@@ -25,6 +25,7 @@
 #include "base/wexception.h"
 
 class FileSystem;
+class Texture;
 class StreamWrite;
 class Surface;
 struct SDL_Surface;
@@ -43,12 +44,11 @@
 };
 
 /// Loads the image 'fn' from 'fs'.
-Surface* load_image(const std::string& fn, FileSystem* fs = nullptr);
+Texture* load_image(const std::string& fn, FileSystem* fs = nullptr);
 
 /// Loads the image 'fn' from 'fs' into an SDL_Surface. Caller must SDL_FreeSurface() the returned value.
 SDL_Surface* load_image_as_sdl_surface(const std::string& fn, FileSystem* fs = nullptr);
 
-
 /// Saves the 'surface' to 'sw' as a PNG.
 bool save_surface_to_png(Surface* surface, StreamWrite* sw);
 

=== modified file 'src/graphic/image_transformations.cc'
--- src/graphic/image_transformations.cc	2014-11-22 21:31:21 +0000
+++ src/graphic/image_transformations.cc	2014-11-24 07:32:35 +0000
@@ -28,8 +28,8 @@
 #include "base/macros.h"
 #include "graphic/color.h"
 #include "graphic/graphic.h"
-#include "graphic/surface.h"
-#include "graphic/surface_cache.h"
+#include "graphic/texture.h"
+#include "graphic/texture_cache.h"
 
 using namespace std;
 
@@ -44,24 +44,24 @@
  * Create and return an \ref SDL_Surface that contains the given sub-rectangle
  * of the given pixel region.
  */
-SDL_Surface* extract_sdl_surface(Surface & surf, Rect srcrect)
+SDL_Surface* extract_sdl_surface(Texture & texture, Rect srcrect)
 {
 	assert(srcrect.x >= 0);
 	assert(srcrect.y >= 0);
-	assert(srcrect.x + srcrect.w <= surf.width());
-	assert(srcrect.y + srcrect.h <= surf.height());
+	assert(srcrect.x + srcrect.w <= texture.width());
+	assert(srcrect.y + srcrect.h <= texture.height());
 
-	const SDL_PixelFormat & fmt = surf.format();
+	const SDL_PixelFormat & fmt = texture.format();
 	SDL_Surface * dest = SDL_CreateRGBSurface
 		(SDL_SWSURFACE, srcrect.w, srcrect.h,
 		 fmt.BitsPerPixel, fmt.Rmask, fmt.Gmask, fmt.Bmask, fmt.Amask);
 
-	surf.lock(Surface::Lock_Normal);
+	texture.lock(Surface::Lock_Normal);
 	SDL_LockSurface(dest);
 
-	uint32_t srcpitch = surf.get_pitch();
+	uint32_t srcpitch = texture.get_pitch();
 	uint32_t rowsize = srcrect.w * fmt.BytesPerPixel;
-	uint8_t * srcpix = surf.get_pixels() + srcpitch * srcrect.y + fmt.BytesPerPixel * srcrect.x;
+	uint8_t * srcpix = texture.get_pixels() + srcpitch * srcrect.y + fmt.BytesPerPixel * srcrect.x;
 	uint8_t * dstpix = static_cast<uint8_t *>(dest->pixels);
 
 	for (uint32_t y = 0; y < srcrect.h; ++y) {
@@ -71,7 +71,7 @@
 	}
 
 	SDL_UnlockSurface(dest);
-	surf.unlock(Surface::Unlock_NoChange);
+	texture.unlock(Surface::Unlock_NoChange);
 
 	return dest;
 }
@@ -79,7 +79,7 @@
 /**
  * Produces a resized version of the specified image
  */
-Surface* resize_surface(Surface* src, uint32_t w, uint32_t h) {
+Texture* resize_surface(Texture* src, uint32_t w, uint32_t h) {
 	assert(w != src->width() || h != src->height());
 
 	// First step: compute scaling factors
@@ -89,7 +89,7 @@
 	SDL_Surface * srcsdl = extract_sdl_surface(*src, srcrect);
 	bool free_source = true;
 
-	// If we actually shrink a surface, ballpark the zoom so that the shrinking
+	// If we actually shrink a texture, ballpark the zoom so that the shrinking
 	// effect is weakened.
 	int factor = 1;
 	while ((static_cast<double>(w) * factor / srcsdl->w) < 1. ||
@@ -146,29 +146,29 @@
 		zoomed = placed;
 	}
 
-	return Surface::create(zoomed);
+	return new Texture(zoomed);
 }
 
 /**
- * Create a grayed version of the given surface.
+ * Create a grayed version of the given texture.
  */
-Surface* gray_out_surface(Surface* surf) {
-	assert(surf);
-
-	uint16_t w = surf->width();
-	uint16_t h = surf->height();
-	const SDL_PixelFormat & origfmt = surf->format();
-
-	Surface* dest = Surface::create(w, h);
+Texture* gray_out_texture(Texture* texture) {
+	assert(texture);
+
+	uint16_t w = texture->width();
+	uint16_t h = texture->height();
+	const SDL_PixelFormat & origfmt = texture->format();
+
+	Texture* dest = new Texture(w, h);
 	const SDL_PixelFormat & destfmt = dest->format();
 
-	surf->lock(Surface::Lock_Normal);
+	texture->lock(Surface::Lock_Normal);
 	dest->lock(Surface::Lock_Discard);
 	for (uint32_t y = 0; y < h; ++y) {
 		for (uint32_t x = 0; x < w; ++x) {
 			RGBAColor color;
 
-			color.set(origfmt, surf->get_pixel(x, y));
+			color.set(origfmt, texture->get_pixel(x, y));
 
 			//  Halve the opacity to give some difference for image that are
 			//  grayscale to begin with.
@@ -184,32 +184,32 @@
 			dest->set_pixel(x, y, color.map(destfmt));
 		}
 	}
-	surf->unlock(Surface::Unlock_NoChange);
+	texture->unlock(Surface::Unlock_NoChange);
 	dest->unlock(Surface::Unlock_Update);
 
 	return dest;
 }
 
 /**
- * Creates an image with changed luminosity from the given surface.
+ * Creates an image with changed luminosity from the given texture.
  */
-Surface* change_luminosity_of_surface(Surface* surf, float factor, bool halve_alpha) {
-	assert(surf);
-
-	uint16_t w = surf->width();
-	uint16_t h = surf->height();
-	const SDL_PixelFormat & origfmt = surf->format();
-
-	Surface* dest = Surface::create(w, h);
+Texture* change_luminosity_of_texture(Texture* texture, float factor, bool halve_alpha) {
+	assert(texture);
+
+	uint16_t w = texture->width();
+	uint16_t h = texture->height();
+	const SDL_PixelFormat & origfmt = texture->format();
+
+	Texture* dest = new Texture(w, h);
 	const SDL_PixelFormat & destfmt = dest->format();
 
-	surf->lock(Surface::Lock_Normal);
+	texture->lock(Surface::Lock_Normal);
 	dest->lock(Surface::Lock_Discard);
 	for (uint32_t y = 0; y < h; ++y) {
 		for (uint32_t x = 0; x < w; ++x) {
 			RGBAColor color;
 
-			color.set(origfmt, surf->get_pixel(x, y));
+			color.set(origfmt, texture->get_pixel(x, y));
 
 			if (halve_alpha)
 				color.a >>= 1;
@@ -221,7 +221,7 @@
 			dest->set_pixel(x, y, color.map(destfmt));
 		}
 	}
-	surf->unlock(Surface::Unlock_NoChange);
+	texture->unlock(Surface::Unlock_NoChange);
 	dest->unlock(Surface::Unlock_Update);
 
 	return dest;
@@ -229,26 +229,28 @@
 
 // Encodes the given Image into the corresponding image for player color.
 // Takes the neutral set of images and the player color mask.
-Surface* make_playerclr_surface(Surface& orig_surface, Surface& pcmask_surface, const RGBColor& color) {
-	Surface* new_surface = Surface::create(orig_surface.width(), orig_surface.height());
-
-	const SDL_PixelFormat & fmt = orig_surface.format();
-	const SDL_PixelFormat & fmt_pc = pcmask_surface.format();
-	const SDL_PixelFormat & destfmt = new_surface->format();
-
-	orig_surface.lock(Surface::Lock_Normal);
-	pcmask_surface.lock(Surface::Lock_Normal);
-	new_surface->lock(Surface::Lock_Discard);
+Texture* make_playerclr_texture(Texture& original_texture,
+                                         Texture& pcmask_texture,
+                                         const RGBColor& color) {
+	Texture* new_texture = new Texture(original_texture.width(), original_texture.height());
+
+	const SDL_PixelFormat & fmt = original_texture.format();
+	const SDL_PixelFormat & fmt_pc = pcmask_texture.format();
+	const SDL_PixelFormat & destfmt = new_texture->format();
+
+	original_texture.lock(Surface::Lock_Normal);
+	pcmask_texture.lock(Surface::Lock_Normal);
+	new_texture->lock(Surface::Lock_Discard);
 	// This could be done significantly faster, but since we
 	// cache the result, let's keep it simple for now.
-	for (uint32_t y = 0; y < orig_surface.height(); ++y) {
-		for (uint32_t x = 0; x < orig_surface.width(); ++x) {
+	for (uint32_t y = 0; y < original_texture.height(); ++y) {
+		for (uint32_t x = 0; x < original_texture.width(); ++x) {
 			RGBAColor source;
 			RGBAColor mask;
 			RGBAColor product;
 
-			source.set(fmt, orig_surface.get_pixel(x, y));
-			mask.set(fmt_pc, pcmask_surface.get_pixel(x, y));
+			source.set(fmt, original_texture.get_pixel(x, y));
+			mask.set(fmt_pc, pcmask_texture.get_pixel(x, y));
 
 			if
 				(uint32_t const influence =
@@ -277,45 +279,45 @@
 					product = source;
 				}
 
-			new_surface->set_pixel(x, y, product.map(destfmt));
+			new_texture->set_pixel(x, y, product.map(destfmt));
 		}
 	}
-	orig_surface.unlock(Surface::Unlock_NoChange);
-	pcmask_surface.unlock(Surface::Unlock_NoChange);
-	new_surface->unlock(Surface::Unlock_Update);
+	original_texture.unlock(Surface::Unlock_NoChange);
+	pcmask_texture.unlock(Surface::Unlock_NoChange);
+	new_texture->unlock(Surface::Unlock_Update);
 
-	return new_surface;
+	return new_texture;
 }
 
 // An Image implementation that is the transformation of another Image. Uses
-// the SurfaceCache to avoid recalculating the transformation too often. No
+// the TextureCache to avoid recalculating the transformation too often. No
 // ownerships are taken.
 class TransformedImage : public Image {
 public:
-	TransformedImage(const string& ghash, const Image& original, SurfaceCache* surface_cache) :
-		hash_(ghash), original_(original), surface_cache_(surface_cache) {}
+	TransformedImage(const string& ghash, const Image& original, TextureCache* texture_cache) :
+		hash_(ghash), original_(original), texture_cache_(texture_cache) {}
 	virtual ~TransformedImage() {}
 
 	// Implements Image.
 	uint16_t width() const override {return original_.width();}
 	uint16_t height() const override {return original_.height();}
 	const string& hash() const override {return hash_;}
-	Surface* surface() const override {
-		Surface* surf = surface_cache_->get(hash_);
-		if (surf)
-			return surf;
+	Texture* texture() const override {
+		Texture* texture = texture_cache_->get(hash_);
+		if (texture)
+			return texture;
 
-		surf = recalculate_surface();
-		surface_cache_->insert(hash_, surf, true);
-		return surf;
+		texture = recalculate_texture();
+		texture_cache_->insert(hash_, texture, true);
+		return texture;
 	}
 
-	virtual Surface* recalculate_surface() const = 0;
+	virtual Texture* recalculate_texture() const = 0;
 
 protected:
 	const string hash_;
 	const Image& original_;
-	SurfaceCache* const surface_cache_;  // not owned
+	TextureCache* const texture_cache_;  // not owned
 };
 
 // A resized copy of an Image.
@@ -323,8 +325,8 @@
 public:
 	ResizedImage
 		(const string& ghash, const Image& original,
-		 SurfaceCache* surface_cache, uint16_t w, uint16_t h)
-		: TransformedImage(ghash, original, surface_cache), w_(w), h_(h) {
+		 TextureCache* texture_cache, uint16_t w, uint16_t h)
+		: TransformedImage(ghash, original, texture_cache), w_(w), h_(h) {
 			assert(w != original.width() || h != original.height());
 	}
 	virtual ~ResizedImage() {}
@@ -334,8 +336,8 @@
 	uint16_t height() const override {return h_;}
 
 	// Implements TransformedImage.
-	Surface* recalculate_surface() const override {
-		Surface* rv = resize_surface(original_.surface(), w_, h_);
+	Texture* recalculate_texture() const override {
+		Texture* rv = resize_surface(original_.texture(), w_, h_);
 		return rv;
 	}
 
@@ -346,14 +348,14 @@
 // A grayed out copy of an Image.
 class GrayedOutImage : public TransformedImage {
 public:
-	GrayedOutImage(const string& ghash, const Image& original, SurfaceCache* surface_cache) :
-		TransformedImage(ghash, original, surface_cache)
+	GrayedOutImage(const string& ghash, const Image& original, TextureCache* texture_cache) :
+		TransformedImage(ghash, original, texture_cache)
 	{}
 	virtual ~GrayedOutImage() {}
 
 	// Implements TransformedImage.
-	Surface* recalculate_surface() const override {
-		return gray_out_surface(original_.surface());
+	Texture* recalculate_texture() const override {
+		return gray_out_texture(original_.texture());
 	}
 };
 
@@ -362,16 +364,16 @@
 public:
 	ChangeLuminosityImage
 		(const string& ghash, const Image& original,
-		 SurfaceCache* surface_cache, float factor, bool halve_alpha)
-		: TransformedImage(ghash, original, surface_cache),
+		 TextureCache* texture_cache, float factor, bool halve_alpha)
+		: TransformedImage(ghash, original, texture_cache),
 		  factor_(factor),
 		  halve_alpha_(halve_alpha)
 	{}
 	virtual ~ChangeLuminosityImage() {}
 
 	// Implements TransformedImage.
-	Surface* recalculate_surface() const override {
-		return change_luminosity_of_surface(original_.surface(), factor_, halve_alpha_);
+	Texture* recalculate_texture() const override {
+		return change_luminosity_of_texture(original_.texture(), factor_, halve_alpha_);
 	}
 
 private:
@@ -385,14 +387,14 @@
 public:
 	PlayerColoredImage
 		(const string& ghash, const Image& original,
-		 SurfaceCache* surface_cache, const RGBColor& color, const Image& mask)
-		: TransformedImage(ghash, original, surface_cache), color_(color), mask_(mask)
+		 TextureCache* texture_cache, const RGBColor& color, const Image& mask)
+		: TransformedImage(ghash, original, texture_cache), color_(color), mask_(mask)
 		{}
 	virtual ~PlayerColoredImage() {}
 
 	// Implements TransformedImage.
-	Surface* recalculate_surface() const override {
-		return make_playerclr_surface(*original_.surface(), *mask_.surface(), color_);
+	Texture* recalculate_texture() const override {
+		return make_playerclr_texture(*original_.texture(), *mask_.texture(), color_);
 	}
 
 private:
@@ -425,7 +427,7 @@
 	if (g_gr->images().has(new_hash))
 		return g_gr->images().get(new_hash);
 	return
-		g_gr->images().insert(new ResizedImage(new_hash, *original, &g_gr->surfaces(), w, h));
+		g_gr->images().insert(new ResizedImage(new_hash, *original, &g_gr->textures(), w, h));
 }
 
 const Image* gray_out(const Image* original) {
@@ -433,7 +435,7 @@
 	if (g_gr->images().has(new_hash))
 		return g_gr->images().get(new_hash);
 	return
-		g_gr->images().insert(new GrayedOutImage(new_hash, *original, &g_gr->surfaces()));
+		g_gr->images().insert(new GrayedOutImage(new_hash, *original, &g_gr->textures()));
 }
 
 const Image* change_luminosity(const Image* original, float factor, bool halve_alpha) {
@@ -443,7 +445,7 @@
 		return g_gr->images().get(new_hash);
 	return
 		g_gr->images().insert
-			(new ChangeLuminosityImage(new_hash, *original, &g_gr->surfaces(), factor, halve_alpha));
+			(new ChangeLuminosityImage(new_hash, *original, &g_gr->textures(), factor, halve_alpha));
 }
 
 const Image* player_colored(const RGBColor& clr, const Image* original, const Image* mask) {
@@ -455,7 +457,7 @@
 		return g_gr->images().get(new_hash);
 	return
 		g_gr->images().insert
-			(new PlayerColoredImage(new_hash, *original, &g_gr->surfaces(), clr, *mask));
+			(new PlayerColoredImage(new_hash, *original, &g_gr->textures(), clr, *mask));
 }
 
 }  // namespace ImageTransformations

=== modified file 'src/graphic/in_memory_image.cc'
--- src/graphic/in_memory_image.cc	2014-07-26 10:43:23 +0000
+++ src/graphic/in_memory_image.cc	2014-11-24 07:32:35 +0000
@@ -22,15 +22,15 @@
 #include <memory>
 
 #include "graphic/image.h"
-#include "graphic/surface.h"
+#include "graphic/texture.h"
 
 using namespace std;
 
 // An Image implementation the does !not! cache its Surface in the
-// SurfaceCache. Avoid using this whenever possible and also do not store it in
+// TextureCache. Avoid using this whenever possible and also do not store it in
 // the ImageCache.
 //
-// This is only used when the surface can not be easily recalculated on the fly
+// This is only used when the texture can not be easily recalculated on the fly
 // or if ownership of the image is managed by the caller itself. Note that this
 // is always tricky because Widelands assumes in many places that Images can be
 // relied to exist forever. So when you pass out a pointer to your
@@ -38,24 +38,24 @@
 // or prepare for core dumps.
 class InMemoryImage : public Image {
 public:
-	InMemoryImage(const string& ghash, Surface* surf) :
-		hash_(ghash), surf_(surf) {}
+	InMemoryImage(const string& ghash, Texture* texture) :
+		hash_(ghash), texture_(texture) {}
 	virtual ~InMemoryImage() {
 	}
 
 	// Implements Image.
-	uint16_t width() const override {return surf_->width();}
-	uint16_t height() const override {return surf_->height();}
+	uint16_t width() const override {return texture_->width();}
+	uint16_t height() const override {return texture_->height();}
 	// Note: hash will mostly be dummy values for this implementation. It should
 	// not wind up in ImageCache, otherwise the ownership question is not clear.
 	const string& hash() const override {return hash_;}
-	Surface* surface() const override {return surf_.get();}
+	Texture* texture() const override {return texture_.get();}
 
 private:
 	const string hash_;
-	std::unique_ptr<Surface> surf_;
+	std::unique_ptr<Texture> texture_;
 };
 
-const Image* new_in_memory_image(const string& hash, Surface* surf) {
-	return new InMemoryImage(hash, surf);
+const Image* new_in_memory_image(const string& hash, Texture* texture) {
+	return new InMemoryImage(hash, texture);
 }

=== modified file 'src/graphic/in_memory_image.h'
--- src/graphic/in_memory_image.h	2014-07-05 16:41:51 +0000
+++ src/graphic/in_memory_image.h	2014-11-24 07:32:35 +0000
@@ -22,9 +22,9 @@
 
 #include <string>
 
+class Texture;
 class Image;
-class Surface;
 
-const Image* new_in_memory_image(const std::string& hash, Surface* surf);
+const Image* new_in_memory_image(const std::string& hash, Texture* texture);
 
 #endif  // end of include guard: WL_GRAPHIC_IN_MEMORY_IMAGE_H

=== modified file 'src/graphic/minimap_renderer.cc'
--- src/graphic/minimap_renderer.cc	2014-09-27 18:53:55 +0000
+++ src/graphic/minimap_renderer.cc	2014-11-24 07:32:35 +0000
@@ -27,7 +27,7 @@
 #include "graphic/graphic.h"
 #include "graphic/image.h"
 #include "graphic/in_memory_image.h"
-#include "graphic/surface.h"
+#include "graphic/terrain_texture.h"
 #include "graphic/texture.h"
 #include "logic/field.h"
 #include "logic/map.h"
@@ -154,16 +154,16 @@
 
 // Does the actual work of drawing the minimap.
 void draw_minimap_int
-	(Surface* surface, const Widelands::EditorGameBase& egbase,
+	(Texture* texture, const Widelands::EditorGameBase& egbase,
 	 const Widelands::Player* player, const Point& viewpoint, MiniMapLayer layers)
 {
 	const Widelands::Map & map = egbase.map();
 
-	uint8_t* const pixels = surface->get_pixels();
-	const SDL_PixelFormat& format = surface->format();
-	const uint16_t pitch = surface->get_pitch();
-	const uint16_t surface_h = surface->height();
-	const uint16_t surface_w = surface->width();
+	uint8_t* const pixels = texture->get_pixels();
+	const SDL_PixelFormat& format = texture->format();
+	const uint16_t pitch = texture->get_pitch();
+	const uint16_t surface_h = texture->height();
+	const uint16_t surface_w = texture->width();
 
 	// size of the display frame
 	int32_t xsize = g_gr->get_xres() / TRIANGLE_WIDTH / 2;
@@ -258,29 +258,29 @@
 
 }  // namespace
 
-std::unique_ptr<Surface> draw_minimap(const EditorGameBase& egbase,
+std::unique_ptr<Texture> draw_minimap(const EditorGameBase& egbase,
                                       const Player* player,
                                       const Point& viewpoint,
                                       MiniMapLayer layers) {
 	// First create a temporary SDL Surface to draw the minimap.
 	// TODO(unknown): Currently the minimap is redrawn every frame. That is not really
-	//       necesary. The created surface could be cached and only redrawn two
+	//       necesary. The created texture could be cached and only redrawn two
 	//       or three times per second
 	const Map& map = egbase.map();
 	const int16_t map_w = (layers & MiniMapLayer::Zoom2) ? map.get_width() * 2 : map.get_width();
 	const int16_t map_h = (layers & MiniMapLayer::Zoom2) ? map.get_height() * 2 : map.get_height();
 
-	Surface* surface = Surface::create(map_w, map_h);
-	assert(surface->format().BytesPerPixel == sizeof(uint32_t));
-
-	surface->fill_rect(Rect(0, 0, surface->width(), surface->height()), RGBAColor(0, 0, 0, 255));
-	surface->lock(Surface::Lock_Normal);
-
-	draw_minimap_int(surface, egbase, player, viewpoint, layers);
-
-	surface->unlock(Surface::Unlock_Update);
-
-	return std::unique_ptr<Surface>(surface);
+	Texture* texture = new Texture(map_w, map_h);
+	assert(texture->format().BytesPerPixel == sizeof(uint32_t));
+
+	texture->fill_rect(Rect(0, 0, texture->width(), texture->height()), RGBAColor(0, 0, 0, 255));
+	texture->lock(Surface::Lock_Normal);
+
+	draw_minimap_int(texture, egbase, player, viewpoint, layers);
+
+	texture->unlock(Surface::Unlock_Update);
+
+	return std::unique_ptr<Texture>(texture);
 }
 
 void write_minimap_image
@@ -309,8 +309,8 @@
 	viewpoint.y -= map_h / 2;
 
 	// Render minimap
-	std::unique_ptr<Surface> surface(draw_minimap(egbase, player, viewpoint, layers));
-	std::unique_ptr<const Image> image(new_in_memory_image("minimap", surface.release()));
+	std::unique_ptr<Texture> texture(draw_minimap(egbase, player, viewpoint, layers));
+	std::unique_ptr<const Image> image(new_in_memory_image("minimap", texture.release()));
 	g_gr->save_png(image.get(), streamwrite);
 	image.reset();
 }

=== modified file 'src/graphic/minimap_renderer.h'
--- src/graphic/minimap_renderer.h	2014-09-27 18:53:55 +0000
+++ src/graphic/minimap_renderer.h	2014-11-24 07:32:35 +0000
@@ -22,9 +22,9 @@
 
 #include <memory>
 
-#include "graphic/rendertarget.h"
-
 class StreamWrite;
+class Texture;
+struct Point;
 
 namespace Widelands {
 	class Player;
@@ -56,7 +56,7 @@
 /// Render the minimap. If player is not nullptr, it renders from that player's
 /// point of view.
 /// \param viewpoint: top left corner in map coordinates
-std::unique_ptr<Surface> draw_minimap
+std::unique_ptr<Texture> draw_minimap
 	(const Widelands::EditorGameBase& egbase, const Widelands::Player* player,
 	 const Point& viewpoint, MiniMapLayer layers);
 

=== modified file 'src/graphic/rendertarget.cc'
--- src/graphic/rendertarget.cc	2014-09-10 13:03:40 +0000
+++ src/graphic/rendertarget.cc	2014-11-24 07:32:35 +0000
@@ -166,7 +166,7 @@
  * If the source surface contains a alpha channel this is used during
  * the blit.
  */
-void RenderTarget::blit(const Point& dst, const Image* image, Composite cm, UI::Align align)
+void RenderTarget::blit(const Point& dst, const Image* image, BlendMode blend_mode, UI::Align align)
 {
 	Point dstpoint(dst);
 
@@ -175,14 +175,14 @@
 	Rect srcrc(Point(0, 0), image->width(), image->height());
 
 	if (to_surface_geometry(&dstpoint, &srcrc))
-		m_surface->blit(dstpoint, image->surface(), srcrc, cm);
+		m_surface->blit(dstpoint, image->texture(), srcrc, blend_mode);
 }
 
 /**
  * Like \ref blit, but use only a sub-rectangle of the source image.
  */
 void RenderTarget::blitrect
-	(const Point& dst, const Image* image, const Rect& gsrcrc, Composite cm)
+	(const Point& dst, const Image* image, const Rect& gsrcrc, BlendMode blend_mode)
 {
 	assert(0 <= gsrcrc.x);
 	assert(0 <= gsrcrc.y);
@@ -196,7 +196,7 @@
 
 	Point dstpt(dst);
 	if (to_surface_geometry(&dstpt, &srcrc))
-		m_surface->blit(dstpt, image->surface(), srcrc, cm);
+		m_surface->blit(dstpt, image->texture(), srcrc, blend_mode);
 }
 
 /**
@@ -205,7 +205,7 @@
  * The pixel from ofs inside image is placed at the top-left corner of
  * the filled rectangle.
  */
-void RenderTarget::tile(const Rect& rect, const Image* image, const Point& gofs, Composite cm)
+void RenderTarget::tile(const Rect& rect, const Image* image, const Point& gofs, BlendMode blend_mode)
 {
 	int32_t srcw = image->width();
 	int32_t srch = image->height();
@@ -251,7 +251,7 @@
 				if (tx + srcrc.w > r.w)
 					srcrc.w = r.w - tx;
 
-				m_surface->blit(r.top_left() + Point(tx, ty), image->surface(), srcrc, cm);
+				m_surface->blit(r.top_left() + Point(tx, ty), image->texture(), srcrc, blend_mode);
 
 				tx += srcrc.w;
 

=== modified file 'src/graphic/rendertarget.h'
--- src/graphic/rendertarget.h	2014-11-02 14:11:52 +0000
+++ src/graphic/rendertarget.h	2014-11-24 07:32:35 +0000
@@ -24,8 +24,8 @@
 
 #include "base/rect.h"
 #include "graphic/align.h"
+#include "graphic/blend_mode.h"
 #include "graphic/color.h"
-#include "graphic/compositemode.h"
 #include "graphic/image.h"
 
 class Surface;
@@ -64,9 +64,20 @@
 	void fill_rect(const Rect&, const RGBAColor&);
 	void brighten_rect(const Rect&, int32_t factor);
 
-	void blit(const Point& dst, const Image* image, Composite cm = CM_UseAlpha, UI::Align = UI::Align_TopLeft);
-	void blitrect(const Point& dst, const Image* image, const Rect& src, Composite cm = CM_UseAlpha);
-	void tile(const Rect&, const Image* image, const Point& ofs, Composite cm = CM_UseAlpha);
+	void blit(const Point& dst,
+	          const Image* image,
+	          BlendMode blend_mode = BlendMode::UseAlpha,
+	          UI::Align = UI::Align_TopLeft);
+
+	void blitrect(const Point& dst,
+	              const Image* image,
+	              const Rect& src,
+	              BlendMode blend_mode = BlendMode::UseAlpha);
+
+	void tile(const Rect&,
+	          const Image* image,
+	          const Point& ofs,
+	          BlendMode blend_mode = BlendMode::UseAlpha);
 
 	void drawanim(const Point& dst, uint32_t animation, uint32_t time, const Widelands::Player* = 0);
 	void drawanimrect

=== renamed file 'src/graphic/gl/surface_screen.cc' => 'src/graphic/screen.cc'
--- src/graphic/gl/surface_screen.cc	2014-11-22 21:31:21 +0000
+++ src/graphic/screen.cc	2014-11-24 07:32:35 +0000
@@ -16,20 +16,20 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-#include "graphic/gl/surface_screen.h"
+#include "graphic/screen.h"
 
 #include <algorithm>
 #include <cassert>
 
 #include "graphic/gl/utils.h"
 
-GLSurfaceScreen::GLSurfaceScreen(uint16_t w, uint16_t h)
+Screen::Screen(uint16_t w, uint16_t h)
 {
 	m_w = w;
 	m_h = h;
 }
 
-void GLSurfaceScreen::pixel_to_gl(float* x, float* y) const {
+void Screen::pixel_to_gl(float* x, float* y) const {
 	*x = (*x / m_w) * 2. - 1.;
 	*y = 1. - (*y / m_h) * 2.;
 }
@@ -38,7 +38,7 @@
  * Swap order of rows in m_pixels, to compensate for the upside-down nature of the
  * OpenGL coordinate system.
  */
-void GLSurfaceScreen::swap_rows()
+void Screen::swap_rows()
 {
 	uint8_t * begin_row = m_pixels.get();
 	uint8_t * end_row = m_pixels.get() + (m_w * (m_h - 1) * 4);
@@ -52,7 +52,7 @@
 	}
 }
 
-void GLSurfaceScreen::lock(Surface::LockMode mode)
+void Screen::lock(Surface::LockMode mode)
 {
 	assert(!m_pixels);
 
@@ -70,7 +70,7 @@
 	}
 }
 
-void GLSurfaceScreen::unlock(Surface::UnlockMode mode)
+void Screen::unlock(Surface::UnlockMode mode)
 {
 	assert(m_pixels);
 

=== renamed file 'src/graphic/gl/surface_screen.h' => 'src/graphic/screen.h'
--- src/graphic/gl/surface_screen.h	2014-11-22 21:31:21 +0000
+++ src/graphic/screen.h	2014-11-24 07:32:35 +0000
@@ -16,18 +16,18 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-#ifndef WL_GRAPHIC_GL_SURFACE_SCREEN_H
-#define WL_GRAPHIC_GL_SURFACE_SCREEN_H
+#ifndef WL_GRAPHIC_SCREEN_H
+#define WL_GRAPHIC_SCREEN_H
 
 #include "graphic/surface.h"
 
 /**
  * This surface represents the screen in OpenGL mode.
  */
-class GLSurfaceScreen : public Surface {
+class Screen : public Surface {
 public:
-	GLSurfaceScreen(uint16_t w, uint16_t h);
-	virtual ~GLSurfaceScreen() {}
+	Screen(uint16_t w, uint16_t h);
+	virtual ~Screen() {}
 
 	/// Interface implementations
 	void lock(LockMode) override;
@@ -39,4 +39,4 @@
 	void swap_rows();
 };
 
-#endif  // end of include guard:
+#endif  // end of include guard: WL_GRAPHIC_SCREEN_H

=== modified file 'src/graphic/surface.cc'
--- src/graphic/surface.cc	2014-11-22 21:31:21 +0000
+++ src/graphic/surface.cc	2014-11-24 07:32:35 +0000
@@ -30,18 +30,9 @@
 #include "graphic/gl/draw_line_program.h"
 #include "graphic/gl/draw_rect_program.h"
 #include "graphic/gl/fill_rect_program.h"
-#include "graphic/gl/surface_texture.h"
 #include "graphic/gl/utils.h"
 #include "graphic/graphic.h"
-
-
-Surface* Surface::create(SDL_Surface* surf) {
-	return new GLSurfaceTexture(surf);
-}
-
-Surface* Surface::create(uint16_t w, uint16_t h) {
-	return new GLSurfaceTexture(w, h);
-}
+#include "graphic/texture.h"
 
 
 uint16_t Surface::width() const {
@@ -167,12 +158,11 @@
 }
 
 void Surface::blit
-	(const Point& dst, const Surface* image, const Rect& srcrc, Composite cm)
+	(const Point& dst, const Texture* texture, const Rect& srcrc, BlendMode blend_mode)
 {
 	glViewport(0, 0, width(), height());
 
 	// Source Rectangle.
-	const GLSurfaceTexture* const texture = static_cast<const GLSurfaceTexture*>(image);
 	FloatRect gl_src_rect;
 	{
 		float x1 = srcrc.x;
@@ -189,5 +179,5 @@
 
 	const FloatRect gl_dst_rect = to_opengl(Rect(dst.x, dst.y, srcrc.w, srcrc.h), ConversionMode::kExact);
 
-	BlitProgram::instance().draw(gl_dst_rect, gl_src_rect, texture->get_gl_texture(), cm);
+	BlitProgram::instance().draw(gl_dst_rect, gl_src_rect, texture->get_gl_texture(), blend_mode);
 }

=== modified file 'src/graphic/surface.h'
--- src/graphic/surface.h	2014-11-22 21:31:21 +0000
+++ src/graphic/surface.h	2014-11-24 07:32:35 +0000
@@ -24,8 +24,10 @@
 
 #include "base/macros.h"
 #include "base/rect.h"
+#include "graphic/blend_mode.h"
 #include "graphic/color.h"
-#include "graphic/compositemode.h"
+
+class Texture;
 
 /**
  * Interface to a basic surfaces that can be used as destination for blitting and drawing.
@@ -33,13 +35,6 @@
  */
 class Surface  {
 public:
-	// Create a new surface from an SDL_Surface. Ownership is taken.
-	static Surface* create(SDL_Surface*);
-
-	// Create a new empty (that is randomly filled) Surface with the given
-	// dimensions.
-	static Surface* create(uint16_t w, uint16_t h);
-
 	Surface() = default;
 	virtual ~Surface() {}
 
@@ -48,10 +43,13 @@
 	uint16_t height() const;
 
 	/// This draws a part of another surface to this surface
-	virtual void blit(const Point&, const Surface*, const Rect& srcrc, Composite cm = CM_UseAlpha);
+	virtual void blit(const Point&,
+	                  const Texture*,
+	                  const Rect& srcrc,
+	                  BlendMode blend_mode = BlendMode::UseAlpha);
 
 	/// Draws a filled rect to the surface. No blending takes place, the values
-	//in the target are just replaced (i.e. / Composite would be CM_Copy).
+	// in the target are just replaced (i.e. / BlendMode would be BlendMode::Copy).
 	virtual void fill_rect(const Rect&, const RGBAColor&);
 
 	/// Draws a rect (frame only) to the surface.

=== renamed file 'src/graphic/texture.cc' => 'src/graphic/terrain_texture.cc'
--- src/graphic/texture.cc	2014-11-23 12:01:59 +0000
+++ src/graphic/terrain_texture.cc	2014-11-24 07:32:35 +0000
@@ -17,7 +17,7 @@
  *
  */
 
-#include "graphic/texture.h"
+#include "graphic/terrain_texture.h"
 
 #include <SDL_image.h>
 
@@ -25,6 +25,7 @@
 #include "base/log.h"
 #include "base/wexception.h"
 #include "graphic/image_io.h"
+#include "graphic/texture.h"
 #include "io/fileread.h"
 #include "io/filesystem/layered_filesystem.h"
 
@@ -35,7 +36,7 @@
  * Currently it converts a 16 bit image to a 8 bit texture. This should
  * be changed to load a 8 bit file directly, however.
  */
-Texture::Texture(const std::vector<std::string>& texture_files, const uint32_t frametime)
+TerrainTexture::TerrainTexture(const std::vector<std::string>& texture_files, const uint32_t frametime)
    : m_frame_num(0), m_frametime(frametime) {
 	if (texture_files.empty()) {
 		throw wexception("No images for texture.");
@@ -47,23 +48,23 @@
 		}
 
 		m_texture_image = fname;
-		SDL_Surface* surf = load_image_as_sdl_surface(fname, g_fs);
-		if (!surf) {
+		SDL_Surface* sdl_surface = load_image_as_sdl_surface(fname, g_fs);
+		if (!sdl_surface) {
 			throw wexception(
 			   "WARNING: Failed to load texture frame %s: %s\n", fname.c_str(), IMG_GetError());
 		}
-		if (surf->w != TEXTURE_WIDTH || surf->h != TEXTURE_HEIGHT) {
-			SDL_FreeSurface(surf);
+		if (sdl_surface->w != kTextureWidth || sdl_surface->h != kTextureHeight) {
+			SDL_FreeSurface(sdl_surface);
 			throw wexception("WARNING: %s: texture must be %ix%i pixels big\n",
 			                 fname.c_str(),
-			                 TEXTURE_WIDTH,
-			                 TEXTURE_HEIGHT);
+			                 kTextureWidth,
+			                 kTextureHeight);
 		}
 
 		// calculate shades on the first frame
-		if (m_gl_textures.empty()) {
-			uint8_t top_left_pixel = static_cast<uint8_t*>(surf->pixels)[0];
-			SDL_Color top_left_pixel_color = surf->format->palette->colors[top_left_pixel];
+		if (m_textures.empty()) {
+			uint8_t top_left_pixel = static_cast<uint8_t*>(sdl_surface->pixels)[0];
+			SDL_Color top_left_pixel_color = sdl_surface->format->palette->colors[top_left_pixel];
 			for (int i = -128; i < 128; i++) {
 				const int shade = 128 + i;
 				int32_t r = std::min<int32_t>((top_left_pixel_color.r * shade) >> 7, 255);
@@ -72,24 +73,26 @@
 				m_minimap_colors[shade] = RGBColor(r, g, b);
 			}
 		}
-		m_gl_textures.emplace_back(new GLSurfaceTexture(surf));
+		m_textures.emplace_back(new Texture(sdl_surface));
 	}
 
-	if (m_gl_textures.empty())
-		throw wexception("Texture has no frames");
+	if (m_textures.empty())
+		throw wexception("TerrainTexture has no frames");
 }
 
-/**
- * Return the basic terrain colour to be used in the minimap.
-*/
-RGBColor Texture::get_minimap_color(int8_t shade) {
+RGBColor TerrainTexture::get_minimap_color(int8_t shade) {
 	return m_minimap_colors[128 + shade];
 }
 
-/**
- * Set the current frame according to the game time.
- */
-void Texture::animate(uint32_t time)
+void TerrainTexture::animate(uint32_t time)
 {
-	m_frame_num = (time / m_frametime) % m_gl_textures.size();
+	m_frame_num = (time / m_frametime) % m_textures.size();
+}
+
+const std::string& TerrainTexture::get_texture_image() const {
+	return m_texture_image;
+}
+
+const Texture& TerrainTexture::texture() const {
+	return *m_textures.at(m_frame_num);
 }

=== renamed file 'src/graphic/texture.h' => 'src/graphic/terrain_texture.h'
--- src/graphic/texture.h	2014-11-22 21:31:21 +0000
+++ src/graphic/terrain_texture.h	2014-11-24 07:32:35 +0000
@@ -17,8 +17,8 @@
  *
  */
 
-#ifndef WL_GRAPHIC_TEXTURE_H
-#define WL_GRAPHIC_TEXTURE_H
+#ifndef WL_GRAPHIC_TERRAIN_TEXTURE_H
+#define WL_GRAPHIC_TERRAIN_TEXTURE_H
 
 #include <memory>
 #include <string>
@@ -27,35 +27,28 @@
 #include <stdint.h>
 
 #include "graphic/colormap.h"
-#include "graphic/gl/surface_texture.h"
-
-/// Textures have a fixed size and are squares.
-/// TEXTURE_HEIGHT is just defined for easier understanding of the code.
-#define TEXTURE_WIDTH 64
-#define TEXTURE_HEIGHT TEXTURE_WIDTH
-
-/** struct Texture
-*
-* Texture represents are terrain texture, which is strictly
-* TEXTURE_WIDTH by TEXTURE_HEIGHT pixels in size. It uses 8 bit color, and
-* a pointer to the corresponding palette and color lookup table is
-* provided.
-*
-* Currently, this is initialized from a 16 bit bitmap. This should be
-* changed to load 8 bit bitmaps directly.
-*/
-struct Texture {
-	Texture(const std::vector<std::string>& texture_files, uint32_t frametime);
-
-	const std::string& get_texture_image() const {
-		return m_texture_image;
-	}
-	uint32_t get_texture() const {
-		return m_gl_textures.at(m_frame_num)->get_gl_texture();
-	}
-
+
+class Texture;
+
+/// TerrainTextures have a fixed size and are squares.
+constexpr int kTextureWidth = 64;
+constexpr int kTextureHeight = kTextureWidth;
+
+// TerrainTexture represents are terrain texture, which is strictly kTextureWidth by
+// kTextureHeight pixels in size.
+struct TerrainTexture {
+	TerrainTexture(const std::vector<std::string>& texture_files, uint32_t frametime);
+
+	// Returns the path to a representative image for this texture.
+	const std::string& get_texture_image() const;
+
+	// Returns the texture for the current animation phase.
+	const Texture& texture() const;
+
+	// Return the basic terrain colour to be used in the minimap.
 	RGBColor get_minimap_color(int8_t shade);
 
+	// Set the current frame according to the game time.
 	void animate(uint32_t time);
 
 private:
@@ -63,7 +56,7 @@
 	int32_t     m_frame_num;
 	std::string m_texture_image;
 	uint32_t    m_frametime;
-	std::vector<std::unique_ptr<GLSurfaceTexture>> m_gl_textures;
+	std::vector<std::unique_ptr<Texture>> m_textures;
 };
 
-#endif  // end of include guard: WL_GRAPHIC_TEXTURE_H
+#endif  // end of include guard: WL_GRAPHIC_TERRAIN_TEXTURE_H

=== modified file 'src/graphic/text/rt_render.cc'
--- src/graphic/text/rt_render.cc	2014-11-02 14:11:52 +0000
+++ src/graphic/text/rt_render.cc	2014-11-24 07:32:35 +0000
@@ -32,10 +32,10 @@
 #include "base/rect.h"
 #include "graphic/image_cache.h"
 #include "graphic/image_io.h"
-#include "graphic/surface.h"
 #include "graphic/text/font_io.h"
 #include "graphic/text/rt_parse.h"
 #include "graphic/text/textstream.h"
+#include "graphic/texture.h"
 
 
 using namespace std;
@@ -108,7 +108,7 @@
 	virtual uint16_t width() = 0;
 	virtual uint16_t height() = 0;
 	virtual uint16_t hotspot_y() = 0;
-	virtual Surface* render(SurfaceCache* surface_cache) = 0;
+	virtual Texture* render(TextureCache* texture_cache) = 0;
 
 	virtual bool is_non_mandatory_space() {return false;}
 	virtual bool is_expanding() {return false;}
@@ -313,7 +313,7 @@
 		return rv;
 	}
 
-	Surface* render(SurfaceCache* surface_cache) override;
+	Texture* render(TextureCache* texture_cache) override;
 
 protected:
 	uint16_t m_w, m_h;
@@ -330,10 +330,10 @@
 uint16_t TextNode::hotspot_y() {
 	return m_font.ascent(m_s.font_style);
 }
-Surface* TextNode::render(SurfaceCache* surface_cache) {
-	const Surface& img = m_font.render(m_txt, m_s.font_color, m_s.font_style, surface_cache);
-	Surface* rv = Surface::create(img.width(), img.height());
-	rv->blit(Point(0, 0), &img, Rect(0, 0, img.width(), img.height()), CM_Copy);
+Texture* TextNode::render(TextureCache* texture_cache) {
+	const Texture& img = m_font.render(m_txt, m_s.font_color, m_s.font_style, texture_cache);
+	Texture* rv = new Texture(img.width(), img.height());
+	rv->blit(Point(0, 0), &img, Rect(0, 0, img.width(), img.height()), BlendMode::Copy);
 	return rv;
 }
 
@@ -348,7 +348,7 @@
 			m_w = w;
 		}
 	virtual ~FillingTextNode() {}
-	Surface* render(SurfaceCache*) override;
+	Texture* render(TextureCache*) override;
 
 	bool is_expanding() override {return m_expanding;}
 	void set_w(uint16_t w) override {m_w = w;}
@@ -356,12 +356,12 @@
 private:
 	bool m_expanding;
 };
-Surface* FillingTextNode::render(SurfaceCache* surface_cache) {
-	const Surface& t = m_font.render(m_txt, m_s.font_color, m_s.font_style, surface_cache);
-	Surface* rv = Surface::create(m_w, m_h);
+Texture* FillingTextNode::render(TextureCache* texture_cache) {
+	const Texture& t = m_font.render(m_txt, m_s.font_color, m_s.font_style, texture_cache);
+	Texture* rv = new Texture(m_w, m_h);
 	for (uint16_t curx = 0; curx < m_w; curx += t.width()) {
 		Rect srcrect(Point(0, 0), min<int>(t.width(), m_w - curx), m_h);
-		rv->blit(Point(curx, 0), &t, srcrect, CM_Copy);
+		rv->blit(Point(curx, 0), &t, srcrect, BlendMode::Copy);
 	}
 	return rv;
 }
@@ -375,13 +375,13 @@
 	WordSpacerNode(IFont& font, NodeStyle& ns) : TextNode(font, ns, " ") {}
 	static void show_spaces(bool t) {m_show_spaces = t;}
 
-	Surface* render(SurfaceCache* surface_cache) override {
+	Texture* render(TextureCache* texture_cache) override {
 		if (m_show_spaces) {
-			Surface* rv = Surface::create(m_w, m_h);
+			Texture* rv = new Texture(m_w, m_h);
 			rv->fill_rect(Rect(0, 0, m_w, m_h), RGBAColor(0xff, 0, 0, 0xff));
 			return rv;
 		}
-		return TextNode::render(surface_cache);
+		return TextNode::render(texture_cache);
 	}
 	bool is_non_mandatory_space() override {return true;}
 
@@ -400,7 +400,7 @@
 	uint16_t height() override {return 0;}
 	uint16_t width() override {return INFINITE_WIDTH; }
 	uint16_t hotspot_y() override {return 0;}
-	Surface* render(SurfaceCache* /* surface_cache */) override {
+	Texture* render(TextureCache* /* texture_cache */) override {
 		assert(false);
 		throw RenderError("This should never be called. This is a bug, please submit a report.");
 	}
@@ -418,8 +418,8 @@
 	uint16_t height() override {return m_h;}
 	uint16_t width() override {return m_w;}
 	uint16_t hotspot_y() override {return m_h;}
-	Surface* render(SurfaceCache* /* surface_cache */) override {
-		Surface* rv = Surface::create(m_w, m_h);
+	Texture* render(TextureCache* /* texture_cache */) override {
+		Texture* rv = new Texture(m_w, m_h);
 
 		// Draw background image (tiling)
 		if (m_bg) {
@@ -430,7 +430,7 @@
 				dst.y = 0;
 				srcrect.w = min<int>(m_bg->width(), m_w - curx);
 				srcrect.h = m_h;
-				rv->blit(dst, m_bg->surface(), srcrect, CM_Copy);
+				rv->blit(dst, m_bg->texture(), srcrect, BlendMode::Copy);
 			}
 		} else {
 			rv->fill_rect(Rect(0, 0, m_w, m_h), RGBAColor(255, 255, 255, 0));
@@ -468,8 +468,8 @@
 	uint16_t width() override {return m_w + m_margin.left + m_margin.right;}
 	uint16_t height() override {return m_h + m_margin.top + m_margin.bottom;}
 	uint16_t hotspot_y() override {return height();}
-	Surface* render(SurfaceCache* surface_cache) override {
-		Surface* rv = Surface::create(width(), height());
+	Texture* render(TextureCache* texture_cache) override {
+		Texture* rv = new Texture(width(), height());
 		rv->fill_rect(Rect(0, 0, rv->width(), rv->height()), RGBAColor(255, 255, 255, 0));
 
 		// Draw Solid background Color
@@ -490,20 +490,20 @@
 					dst.x = curx; dst.y = cury;
 					src.w = min<int>(m_bg_img->width(), m_w + m_margin.left - curx);
 					src.h = min<int>(m_bg_img->height(), m_h + m_margin.top - cury);
-					rv->blit(dst, m_bg_img->surface(), src, CM_Copy);
+					rv->blit(dst, m_bg_img->texture(), src, BlendMode::Copy);
 				}
 			}
 			set_alpha = false;
 		}
 
 		for (RenderNode* n : m_nodes_to_render) {
-			Surface* nsur = n->render(surface_cache);
-			if (nsur) {
+			Texture* node_texture = n->render(texture_cache);
+			if (node_texture) {
 				Point dst = Point(n->x() + m_margin.left, n->y() + m_margin.top);
-				Rect src = Rect(0, 0, nsur->width(), nsur->height());
+				Rect src = Rect(0, 0, node_texture->width(), node_texture->height());
 
-				rv->blit(dst, nsur, src, set_alpha ? CM_Copy : CM_UseAlpha);
-				delete nsur;
+				rv->blit(dst, node_texture, src, set_alpha ? BlendMode::Copy : BlendMode::UseAlpha);
+				delete node_texture;
 			}
 			delete n;
 		}
@@ -545,15 +545,15 @@
 	uint16_t width() override {return m_image.width();}
 	uint16_t height() override {return m_image.height();}
 	uint16_t hotspot_y() override {return m_image.height();}
-	Surface* render(SurfaceCache* surface_cache) override;
+	Texture* render(TextureCache* texture_cache) override;
 
 private:
 	const Image& m_image;
 };
 
-Surface* ImgRenderNode::render(SurfaceCache* /* surface_cache */) {
-	Surface* rv = Surface::create(m_image.width(), m_image.height());
-	rv->blit(Point(0, 0), m_image.surface(), Rect(0, 0, m_image.width(), m_image.height()), CM_Copy);
+Texture* ImgRenderNode::render(TextureCache* /* texture_cache */) {
+	Texture* rv = new Texture(m_image.width(), m_image.height());
+	rv->blit(Point(0, 0), m_image.texture(), Rect(0, 0, m_image.width(), m_image.height()), BlendMode::Copy);
 	return rv;
 }
 // End: Helper Stuff
@@ -946,9 +946,9 @@
 	return i->second(tag, fc, ns, image_cache);
 }
 
-Renderer::Renderer(ImageCache* image_cache, SurfaceCache* surface_cache) :
+Renderer::Renderer(ImageCache* image_cache, TextureCache* texture_cache) :
 	font_cache_(new FontCache()), parser_(new Parser()),
-	image_cache_(image_cache), surface_cache_(surface_cache) {
+	image_cache_(image_cache), texture_cache_(texture_cache) {
 }
 
 Renderer::~Renderer() {
@@ -976,10 +976,10 @@
 	return nodes[0];
 }
 
-Surface* Renderer::render(const string& text, uint16_t width, const TagSet& allowed_tags) {
+Texture* Renderer::render(const string& text, uint16_t width, const TagSet& allowed_tags) {
 	std::unique_ptr<RenderNode> node(layout_(text, width, allowed_tags));
 
-	return node->render(surface_cache_);
+	return node->render(texture_cache_);
 }
 
 IRefMap* Renderer::make_reference_map(const string& text, uint16_t width, const TagSet& allowed_tags) {

=== modified file 'src/graphic/text/rt_render.h'
--- src/graphic/text/rt_render.h	2014-09-14 11:31:58 +0000
+++ src/graphic/text/rt_render.h	2014-11-24 07:32:35 +0000
@@ -29,8 +29,9 @@
 #include "graphic/color.h"
 #include "graphic/image.h"
 
-class SurfaceCache;
+class Texture;
 class ImageCache;
+class TextureCache;
 
 namespace RT {
 
@@ -58,7 +59,7 @@
 	virtual ~IFont() {}
 
 	virtual void dimensions(const std::string&, int, uint16_t *, uint16_t *) = 0;
-	virtual const Surface& render(const std::string&, const RGBColor& clr, int, SurfaceCache*) = 0;
+	virtual const Texture& render(const std::string&, const RGBColor& clr, int, TextureCache*) = 0;
 
 	virtual uint16_t ascent(int) const = 0;
 };
@@ -81,13 +82,13 @@
 class Renderer {
 public:
 	// Ownership is not taken.
-	Renderer(ImageCache* image_cache, SurfaceCache* surface_cache);
+	Renderer(ImageCache* image_cache, TextureCache* texture_cache);
 	~Renderer();
 
 	// Render the given string in the given width. Restricts the allowed tags to
-	// the ones in TagSet. The renderer does not do caching in the SurfaceCache
+	// the ones in TagSet. The renderer does not do caching in the TextureCache
 	// for its individual nodes, but the font render does.
-	Surface* render(const std::string&, uint16_t width, const TagSet& tagset = TagSet());
+	Texture* render(const std::string&, uint16_t width, const TagSet& tagset = TagSet());
 
 	// Returns a reference map of the clickable hyperlinks in the image. This
 	// will do no caching and needs to do all layouting, so do not call this too
@@ -100,7 +101,7 @@
 	std::unique_ptr<FontCache> font_cache_;
 	std::unique_ptr<Parser> parser_;
 	ImageCache* const image_cache_;  // Not owned.
-	SurfaceCache* const surface_cache_;  // Not owned.
+	TextureCache* const texture_cache_;  // Not owned.
 };
 
 }

=== modified file 'src/graphic/text/sdl_ttf_font.cc'
--- src/graphic/text/sdl_ttf_font.cc	2014-11-23 10:13:14 +0000
+++ src/graphic/text/sdl_ttf_font.cc	2014-11-24 07:32:35 +0000
@@ -24,9 +24,9 @@
 #include <boost/format.hpp>
 
 #include "graphic/sdl_utils.h"
-#include "graphic/surface.h"
-#include "graphic/surface_cache.h"
 #include "graphic/text/rt_errors.h"
+#include "graphic/texture.h"
+#include "graphic/texture_cache.h"
 
 using namespace std;
 using namespace boost;
@@ -58,13 +58,13 @@
 	*gw = w; *gh = h;
 }
 
-const Surface& SdlTtfFont::render
-	(const string& txt, const RGBColor& clr, int style, SurfaceCache* surface_cache) {
+const Texture& SdlTtfFont::render
+	(const string& txt, const RGBColor& clr, int style, TextureCache* texture_cache) {
 	const string hash =
 		(boost::format("%s:%s:%i:%02x%02x%02x:%i") % font_name_ % ptsize_ % txt %
 		 static_cast<int>(clr.r) % static_cast<int>(clr.g) % static_cast<int>(clr.b) % style)
 			.str();
-	const Surface* rv = surface_cache->get(hash);
+	const Texture* rv = texture_cache->get(hash);
 	if (rv) return *rv;
 
 	m_set_style(style);
@@ -120,7 +120,7 @@
 	if (!text_surface)
 		throw RenderError((format("Rendering '%s' gave the error: %s") % txt % TTF_GetError()).str());
 
-	return *surface_cache->insert(hash, Surface::create(text_surface), true);
+	return *texture_cache->insert(hash, new Texture(text_surface), true);
 }
 
 uint16_t SdlTtfFont::ascent(int style) const {

=== modified file 'src/graphic/text/sdl_ttf_font.h'
--- src/graphic/text/sdl_ttf_font.h	2014-09-10 16:57:31 +0000
+++ src/graphic/text/sdl_ttf_font.h	2014-11-24 07:32:35 +0000
@@ -37,7 +37,7 @@
 	virtual ~SdlTtfFont();
 
 	void dimensions(const std::string&, int, uint16_t * w, uint16_t * h) override;
-	const Surface& render(const std::string&, const RGBColor& clr, int, SurfaceCache*) override;
+	const Texture& render(const std::string&, const RGBColor& clr, int, TextureCache*) override;
 	uint16_t ascent(int) const override;
 
 private:

=== modified file 'src/graphic/text/test/render.cc'
--- src/graphic/text/test/render.cc	2014-09-20 09:37:47 +0000
+++ src/graphic/text/test/render.cc	2014-11-24 07:32:35 +0000
@@ -25,9 +25,9 @@
 #include <string>
 
 #include "graphic/image_cache.h"
-#include "graphic/surface_cache.h"
 #include "graphic/text/rt_render.h"
 #include "graphic/text/test/paths.h"
+#include "graphic/texture_cache.h"
 #include "io/filesystem/layered_filesystem.h"
 
 StandaloneRenderer::StandaloneRenderer() {
@@ -35,9 +35,9 @@
 	g_fs->add_file_system(&FileSystem::create(WIDELANDS_DATA_DIR));
 	g_fs->add_file_system(&FileSystem::create(RICHTEXT_DATA_DIR));
 
-	surface_cache_.reset(create_surface_cache(500 << 20));  // 500 MB
-	image_cache_.reset(new ImageCache(surface_cache_.get()));
-	renderer_.reset(new RT::Renderer(image_cache_.get(), surface_cache_.get()));
+	texture_cache_.reset(create_texture_cache(500 << 20));  // 500 MB
+	image_cache_.reset(new ImageCache(texture_cache_.get()));
+	renderer_.reset(new RT::Renderer(image_cache_.get(), texture_cache_.get()));
 }
 
 StandaloneRenderer::~StandaloneRenderer() {

=== modified file 'src/graphic/text/test/render.h'
--- src/graphic/text/test/render.h	2014-07-14 10:45:44 +0000
+++ src/graphic/text/test/render.h	2014-11-24 07:32:35 +0000
@@ -36,7 +36,7 @@
 		RT::Renderer* renderer();
 
 	private:
-		std::unique_ptr<SurfaceCache> surface_cache_;
+		std::unique_ptr<TextureCache> texture_cache_;
 		std::unique_ptr<ImageCache> image_cache_;
 		std::unique_ptr<RT::Renderer> renderer_;
 };

=== modified file 'src/graphic/text/test/render_richtext.cc'
--- src/graphic/text/test/render_richtext.cc	2014-11-24 07:32:34 +0000
+++ src/graphic/text/test/render_richtext.cc	2014-11-24 07:32:35 +0000
@@ -33,9 +33,9 @@
 #include "config.h"
 #include "graphic/graphic.h"
 #include "graphic/image_io.h"
-#include "graphic/surface.h"
 #include "graphic/text/rt_errors.h"
 #include "graphic/text/test/render.h"
+#include "graphic/texture.h"
 #include "io/filesystem/filesystem.h"
 #include "io/filesystem/layered_filesystem.h"
 #include "io/streamwrite.h"
@@ -135,11 +135,12 @@
 	StandaloneRenderer standalone_renderer;
 
 	try {
-		std::unique_ptr<Surface> surf(standalone_renderer.renderer()->render(txt, w, allowed_tags));
+		std::unique_ptr<Texture> texture(
+		   standalone_renderer.renderer()->render(txt, w, allowed_tags));
 
 		std::unique_ptr<FileSystem> fs(&FileSystem::create("."));
 		std::unique_ptr<StreamWrite> sw(fs->open_stream_write(outname));
-		if (!save_surface_to_png(surf.get(), sw.get())) {
+		if (!save_surface_to_png(texture.get(), sw.get())) {
 			std::cout << "Could not encode PNG." << std::endl;
 		}
 	} catch (RT::Exception& e) {

=== renamed file 'src/graphic/gl/surface_texture.cc' => 'src/graphic/texture.cc'
--- src/graphic/gl/surface_texture.cc	2014-11-23 10:13:14 +0000
+++ src/graphic/texture.cc	2014-11-24 07:32:35 +0000
@@ -16,7 +16,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-#include "graphic/gl/surface_texture.h"
+#include "graphic/texture.h"
 
 #include <cassert>
 
@@ -77,7 +77,7 @@
  *
  * The initial data of the texture is undefined.
  */
-GLSurfaceTexture::GLSurfaceTexture(int w, int h)
+Texture::Texture(int w, int h)
 {
 	init(w, h);
 
@@ -94,7 +94,7 @@
  *
  * \note Takes ownership of the given surface.
  */
-GLSurfaceTexture::GLSurfaceTexture(SDL_Surface * surface, bool intensity)
+Texture::Texture(SDL_Surface * surface, bool intensity)
 {
 	init(surface->w, surface->h);
 
@@ -132,17 +132,17 @@
 	SDL_FreeSurface(surface);
 }
 
-GLSurfaceTexture::~GLSurfaceTexture()
+Texture::~Texture()
 {
 	glDeleteTextures(1, &m_texture);
 }
 
-void GLSurfaceTexture::pixel_to_gl(float* x, float* y) const {
+void Texture::pixel_to_gl(float* x, float* y) const {
 	*x = (*x / m_w) * 2. - 1.;
 	*y = (*y / m_h) * 2. - 1.;
 }
 
-void GLSurfaceTexture::init(uint16_t w, uint16_t h)
+void Texture::init(uint16_t w, uint16_t h)
 {
 	m_w = w;
 	m_h = h;
@@ -160,7 +160,7 @@
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 }
 
-void GLSurfaceTexture::lock(LockMode mode) {
+void Texture::lock(LockMode mode) {
 	if (m_w <= 0 || m_h <= 0) {
 		return;
 	}
@@ -174,7 +174,7 @@
 	}
 }
 
-void GLSurfaceTexture::unlock(UnlockMode mode) {
+void Texture::unlock(UnlockMode mode) {
 	if (m_w <= 0 || m_h <= 0) {
 		return;
 	}
@@ -190,7 +190,7 @@
 	m_pixels.reset(nullptr);
 }
 
-void GLSurfaceTexture::draw_rect(const Rect& rectangle, const RGBColor& clr)
+void Texture::draw_rect(const Rect& rectangle, const RGBColor& clr)
 {
 	if (m_w <= 0 || m_h <= 0) {
 		return;
@@ -204,7 +204,7 @@
 /**
  * Draws a filled rectangle
  */
-void GLSurfaceTexture::fill_rect(const Rect& rectangle, const RGBAColor& clr)
+void Texture::fill_rect(const Rect& rectangle, const RGBAColor& clr)
 {
 	if (m_w <= 0 || m_h <= 0) {
 		return;
@@ -218,7 +218,7 @@
 /**
  * Change the brightness of the given rectangle
  */
-void GLSurfaceTexture::brighten_rect(const Rect& rectangle, const int32_t factor)
+void Texture::brighten_rect(const Rect& rectangle, const int32_t factor)
 {
 	if (m_w <= 0 || m_h <= 0) {
 		return;
@@ -229,7 +229,7 @@
 	reset_gl();
 }
 
-void GLSurfaceTexture::draw_line
+void Texture::draw_line
 	(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const RGBColor& color, uint8_t gwidth)
 {
 	if (m_w <= 0 || m_h <= 0) {
@@ -241,14 +241,14 @@
 	reset_gl();
 }
 
-void GLSurfaceTexture::blit
-	(const Point& dst, const Surface* src, const Rect& srcrc, Composite cm)
+void Texture::blit
+	(const Point& dst, const Texture* src, const Rect& srcrc, BlendMode blend_mode)
 {
 	if (m_w <= 0 || m_h <= 0) {
 		return;
 	}
 
 	setup_gl(m_texture);
-	Surface::blit(dst, src, srcrc, cm);
+	Surface::blit(dst, src, srcrc, blend_mode);
 	reset_gl();
 }

=== renamed file 'src/graphic/gl/surface_texture.h' => 'src/graphic/texture.h'
--- src/graphic/gl/surface_texture.h	2014-11-22 21:31:21 +0000
+++ src/graphic/texture.h	2014-11-24 07:32:35 +0000
@@ -16,20 +16,25 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-#ifndef WL_GRAPHIC_GL_SURFACE_TEXTURE_H
-#define WL_GRAPHIC_GL_SURFACE_TEXTURE_H
+#ifndef WL_GRAPHIC_TEXTURE_H
+#define WL_GRAPHIC_TEXTURE_H
 
 #include "graphic/gl/system_headers.h"
 #include "graphic/surface.h"
 
 struct SDL_Surface;
 
-class GLSurfaceTexture : public Surface {
+class Texture : public Surface {
 public:
-	GLSurfaceTexture(SDL_Surface * surface, bool intensity = false);
-	GLSurfaceTexture(int w, int h);
-
-	virtual ~GLSurfaceTexture();
+	// Create a new surface from an SDL_Surface. If intensity is true, an GL_INTENSITY texture
+	// is created. Ownership is taken.
+	Texture(SDL_Surface * surface, bool intensity = false);
+
+	// Create a new empty (that is randomly filled) Surface with the given
+	// dimensions.
+	Texture(int w, int h);
+
+	virtual ~Texture();
 
 	/// Interface implementation
 	//@{
@@ -48,7 +53,10 @@
 	void brighten_rect(const Rect&, int32_t factor) override;
 	virtual void draw_line
 		(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const RGBColor&, uint8_t width) override;
-	void blit(const Point&, const Surface*, const Rect& srcrc, Composite cm) override;
+	void blit(const Point&,
+	          const Texture*,
+	          const Rect& srcrc,
+	          BlendMode blend_mode = BlendMode::UseAlpha) override;
 
 	GLuint get_gl_texture() const {return m_texture;}
 
@@ -59,4 +67,4 @@
 	GLuint m_texture;
 };
 
-#endif  // end of include guard: WL_GRAPHIC_GL_SURFACE_TEXTURE_H
+#endif  // end of include guard: WL_GRAPHIC_TEXTURE_H

=== renamed file 'src/graphic/surface_cache.cc' => 'src/graphic/texture_cache.cc'
--- src/graphic/surface_cache.cc	2014-09-14 11:31:58 +0000
+++ src/graphic/texture_cache.cc	2014-11-24 07:32:35 +0000
@@ -17,7 +17,7 @@
  *
  */
 
-#include "graphic/surface_cache.h"
+#include "graphic/texture_cache.h"
 
 #include <cassert>
 #include <list>
@@ -26,33 +26,33 @@
 
 #include <SDL.h>
 
-#include "graphic/surface.h"
+#include "graphic/texture.h"
 
 using namespace std;
 
 // I took inspiration from http://timday.bitbucket.org/lru.html, but our use
 // case here is a little different.
 namespace  {
-class SurfaceCacheImpl : public SurfaceCache {
+class TextureCacheImpl : public TextureCache {
 public:
-	SurfaceCacheImpl(uint32_t max_transient_memory) :
+	TextureCacheImpl(uint32_t max_transient_memory) :
 		max_transient_memory_(max_transient_memory), used_transient_memory_(0) {}
-	virtual ~SurfaceCacheImpl();
+	virtual ~TextureCacheImpl();
 
-	// Implements SurfaceCache.
+	// Implements TextureCache.
 	void flush() override;
-	Surface* get(const string& hash) override;
-	Surface* insert(const string& hash, Surface*, bool) override;
+	Texture* get(const string& hash) override;
+	Texture* insert(const string& hash, Texture*, bool) override;
 
 private:
 	void drop();
 
 	using AccessHistory = list<string>;
 	struct Entry {
-		Entry(Surface* gs, const AccessHistory::iterator& it, bool transient) :
-			surface(gs), is_transient(transient), last_access(SDL_GetTicks()), list_iterator(it) {}
+		Entry(Texture* gs, const AccessHistory::iterator& it, bool transient) :
+			texture(gs), is_transient(transient), last_access(SDL_GetTicks()), list_iterator(it) {}
 
-		std::unique_ptr<Surface> surface;
+		std::unique_ptr<Texture> texture;
 		bool is_transient;
 		uint32_t last_access;  // Mainly for debugging and analysis.
 		const AccessHistory::iterator list_iterator;  // Only valid if is_transient is true.
@@ -65,11 +65,11 @@
 	AccessHistory access_history_;
 };
 
-SurfaceCacheImpl::~SurfaceCacheImpl() {
+TextureCacheImpl::~TextureCacheImpl() {
 	flush();
 }
 
-void SurfaceCacheImpl::flush() {
+void TextureCacheImpl::flush() {
 	for (Container::iterator it = entries_.begin(); it != entries_.end(); ++it) {
 		delete it->second;
 	}
@@ -78,7 +78,7 @@
 	used_transient_memory_ = 0;
 }
 
-Surface* SurfaceCacheImpl::get(const string& hash) {
+Texture* TextureCacheImpl::get(const string& hash) {
 	const Container::iterator it = entries_.find(hash);
 	if (it == entries_.end())
 		return nullptr;
@@ -89,30 +89,29 @@
 		access_history_.splice(access_history_.end(), access_history_, it->second->list_iterator);
 		it->second->last_access = SDL_GetTicks();
 	}
-	return it->second->surface.get();
+	return it->second->texture.get();
 }
 
-Surface* SurfaceCacheImpl::insert(const string& hash, Surface* surf, bool transient) {
+Texture* TextureCacheImpl::insert(const string& hash, Texture* texture, bool transient) {
 	assert(entries_.find(hash) == entries_.end());
 
 	if (transient) {
-		const uint32_t surface_size = surf->width() * surf->height() * 4;
-		while (used_transient_memory_ + surface_size > max_transient_memory_) {
+		const uint32_t texture_size = texture->width() * texture->height() * 4;
+		while (used_transient_memory_ + texture_size > max_transient_memory_) {
 			drop();
 		}
 
 		// Record hash as most-recently-used.
 		AccessHistory::iterator it = access_history_.insert(access_history_.end(), hash);
-		used_transient_memory_ += surface_size;
-		entries_.insert(make_pair(hash, new Entry(surf, it, true)));
+		used_transient_memory_ += texture_size;
+		entries_.insert(make_pair(hash, new Entry(texture, it, true)));
 	} else {
-		entries_.insert(make_pair(hash, new Entry(surf, access_history_.end(), false)));
+		entries_.insert(make_pair(hash, new Entry(texture, access_history_.end(), false)));
 	}
-
-	return surf;
+	return texture;
 }
 
-void SurfaceCacheImpl::drop() {
+void TextureCacheImpl::drop() {
 	assert(!access_history_.empty());
 
 	// Identify least recently used key
@@ -120,8 +119,8 @@
 	assert(it != entries_.end());
 	assert(it->second->is_transient);
 
-	const uint32_t surface_size = it->second->surface->width() * it->second->surface->height() * 4;
-	used_transient_memory_ -= surface_size;
+	const uint32_t texture_size = it->second->texture->width() * it->second->texture->height() * 4;
+	used_transient_memory_ -= texture_size;
 
 	// Erase both elements to completely purge record
 	delete it->second;
@@ -131,6 +130,6 @@
 
 }  // namespace
 
-SurfaceCache* create_surface_cache(uint32_t transient_memory_in_bytes) {
-	return new SurfaceCacheImpl(transient_memory_in_bytes);
+TextureCache* create_texture_cache(uint32_t transient_memory_in_bytes) {
+	return new TextureCacheImpl(transient_memory_in_bytes);
 }

=== renamed file 'src/graphic/surface_cache.h' => 'src/graphic/texture_cache.h'
--- src/graphic/surface_cache.h	2014-07-14 19:48:07 +0000
+++ src/graphic/texture_cache.h	2014-11-24 07:32:35 +0000
@@ -17,8 +17,8 @@
  *
  */
 
-#ifndef WL_GRAPHIC_SURFACE_CACHE_H
-#define WL_GRAPHIC_SURFACE_CACHE_H
+#ifndef WL_GRAPHIC_TEXTURE_CACHE_H
+#define WL_GRAPHIC_TEXTURE_CACHE_H
 
 #include <string>
 
@@ -26,7 +26,7 @@
 
 #include "base/macros.h"
 
-class Surface;
+class Texture;
 
 // Caches Surfaces. It contains surfaces which must not be deleted and
 // transient surfaces that are always free to be deleted - somebody else must
@@ -35,32 +35,32 @@
 // Nobody in Widelands should hold onto a Surface they get from this class,
 // instead, they should use it only temporarily and rerequest it whenever they
 // need it.
-class SurfaceCache {
+class TextureCache {
 public:
-	SurfaceCache() {}
-	virtual ~SurfaceCache() {}
+	TextureCache() {}
+	virtual ~TextureCache() {}
 
 	/// Deletes all surfaces in the cache leaving it as if it were just created.
 	virtual void flush() = 0;
 
 	/// Returns an entry if it is cached, nullptr otherwise.
-	virtual Surface* get(const std::string& hash) = 0;
+	virtual Texture* get(const std::string& hash) = 0;
 
-	// Inserts this entry into the SurfaceCache. asserts() that there is no
+	// Inserts this entry into the TextureCache. asserts() that there is no
 	// entry with this hash already cached. Returns the given Surface for
 	// convenience. If 'transient' is false, this surface will not be deleted
 	// automatically - use this if surfaces are around for a long time and
 	// recreation is expensive (i.e. images loaded from disk).
-	virtual Surface* insert(const std::string& hash, Surface*, bool transient) = 0;
+	virtual Texture* insert(const std::string& hash, Texture*, bool transient) = 0;
 
 private:
-	DISALLOW_COPY_AND_ASSIGN(SurfaceCache);
+	DISALLOW_COPY_AND_ASSIGN(TextureCache);
 };
 
 // Create a new Cache whichs combined pixels in all transient surfaces are
 // always below the given limit (Note: there is overhead for class members
 // which is not counted as the pixels make up the bulk of the size of a
 // surface).
-SurfaceCache* create_surface_cache(uint32_t transient_memory_in_bytes);
+TextureCache* create_texture_cache(uint32_t transient_memory_in_bytes);
 
-#endif  // end of include guard: WL_GRAPHIC_SURFACE_CACHE_H
+#endif  // end of include guard: WL_GRAPHIC_TEXTURE_CACHE_H

=== modified file 'src/logic/building.cc'
--- src/logic/building.cc	2014-11-02 14:11:52 +0000
+++ src/logic/building.cc	2014-11-24 07:32:35 +0000
@@ -732,7 +732,7 @@
 	if (dpyflags & InteractiveBase::dfShowCensus) {
 		const std::string info = info_string(igbase.building_census_format());
 		if (!info.empty()) {
-			dst.blit(pos - Point(0, 48), UI::g_fh1->render(info), CM_UseAlpha, UI::Align_Center);
+			dst.blit(pos - Point(0, 48), UI::g_fh1->render(info), BlendMode::UseAlpha, UI::Align_Center);
 		}
 	}
 
@@ -744,7 +744,7 @@
 				return;
 		const std::string info = info_string(igbase.building_statistics_format());
 		if (!info.empty()) {
-			dst.blit(pos - Point(0, 35), UI::g_fh1->render(info), CM_UseAlpha, UI::Align_Center);
+			dst.blit(pos - Point(0, 35), UI::g_fh1->render(info), BlendMode::UseAlpha, UI::Align_Center);
 		}
 	}
 }

=== modified file 'src/logic/immovable.cc'
--- src/logic/immovable.cc	2014-11-02 14:11:52 +0000
+++ src/logic/immovable.cc	2014-11-24 07:32:35 +0000
@@ -562,7 +562,7 @@
 	dst.drawanimrect
 		(pos, m_anim, current_frame * frametime, get_owner(), Rect(Point(0, curh - lines), curw, lines));
 
-	// Additionnaly, if statistics are enabled, draw a progression string
+	// Additionally, if statistics are enabled, draw a progression string
 	if (game.get_ibase()->get_display_flags() & InteractiveBase::dfShowStatistics) {
 		unsigned int percent = (100 * done / total);
 		m_construct_string =
@@ -570,7 +570,10 @@
 			 % UI_FONT_CLR_DARK_HEX % (boost::format(_("%i%% built")) % percent).str())
 			 .str();
 		m_construct_string = as_uifont(m_construct_string);
-		dst.blit(pos - Point(0, 48), UI::g_fh1->render(m_construct_string), CM_UseAlpha, UI::Align_Center);
+		dst.blit(pos - Point(0, 48),
+		         UI::g_fh1->render(m_construct_string),
+		         BlendMode::UseAlpha,
+		         UI::Align_Center);
 	}
 }
 

=== modified file 'src/logic/map_info.cc'
--- src/logic/map_info.cc	2014-11-24 07:32:34 +0000
+++ src/logic/map_info.cc	2014-11-24 07:32:35 +0000
@@ -29,7 +29,7 @@
 #include "graphic/graphic.h"
 #include "graphic/image_io.h"
 #include "graphic/minimap_renderer.h"
-#include "graphic/surface.h"
+#include "graphic/texture.h"
 #include "io/filesystem/filesystem.h"
 #include "io/filesystem/layered_filesystem.h"
 #include "io/filewrite.h"
@@ -87,7 +87,8 @@
 		ml->preload_map(true);
 		ml->load_map_complete(egbase, true);
 
-		std::unique_ptr<Surface> minimap(draw_minimap(egbase, nullptr, Point(0, 0), MiniMapLayer::Terrain));
+		std::unique_ptr<Texture> minimap(
+		   draw_minimap(egbase, nullptr, Point(0, 0), MiniMapLayer::Terrain));
 
 		// Write minimap
 		{

=== modified file 'src/map_io/map_extradata_packet.cc'
--- src/map_io/map_extradata_packet.cc	2014-09-20 09:37:47 +0000
+++ src/map_io/map_extradata_packet.cc	2014-11-24 07:32:35 +0000
@@ -23,7 +23,7 @@
 
 #include "graphic/graphic.h"
 #include "graphic/in_memory_image.h"
-#include "graphic/surface.h"
+#include "graphic/texture.h"
 #include "io/fileread.h"
 #include "io/filewrite.h"
 #include "logic/editor_game_base.h"
@@ -67,7 +67,7 @@
 							IMG_Load_RW(SDL_RWFromMem(fr.data(0), fr.get_size()), 1);
 						if (!surf)
 							continue; //  Illegal pic. Skip it.
-						image = g_gr->images().insert(new_in_memory_image(hash, Surface::create(surf)));
+						image = g_gr->images().insert(new_in_memory_image(hash, new Texture(surf)));
 					} else {
 						image = g_gr->images().get(hash);
 					}

=== modified file 'src/map_io/map_saver.cc'
--- src/map_io/map_saver.cc	2014-11-22 15:27:45 +0000
+++ src/map_io/map_saver.cc	2014-11-24 07:32:35 +0000
@@ -26,7 +26,7 @@
 #include "base/wexception.h"
 #include "graphic/image_io.h"
 #include "graphic/minimap_renderer.h"
-#include "graphic/surface.h"
+#include "graphic/texture.h"
 #include "io/filesystem/filesystem.h"
 #include "io/filewrite.h"
 #include "logic/editor_game_base.h"
@@ -217,7 +217,7 @@
 
 	// Write minimap
 	{
-		std::unique_ptr<Surface> minimap(
+		std::unique_ptr<Texture> minimap(
 		   draw_minimap(m_egbase, nullptr, Point(0, 0), MiniMapLayer::Terrain));
 		FileWrite fw;
 		save_surface_to_png(minimap.get(), &fw);

=== modified file 'src/ui_basic/progressbar.cc'
--- src/ui_basic/progressbar.cc	2014-11-02 14:11:52 +0000
+++ src/ui_basic/progressbar.cc	2014-11-24 07:32:35 +0000
@@ -109,6 +109,6 @@
 	const std::string progress_text =
 		(boost::format("<font color=%1$s>%2$i%%</font>") % "ffffff" % percent).str();
 	const Point pos(get_w() / 2, get_h() / 2);
-	dst.blit(pos, UI::g_fh1->render(as_uifont(progress_text)), CM_UseAlpha, Align_Center);
+	dst.blit(pos, UI::g_fh1->render(as_uifont(progress_text)), BlendMode::UseAlpha, Align_Center);
 }
 }

=== modified file 'src/ui_basic/window.cc'
--- src/ui_basic/window.cc	2014-11-22 11:51:38 +0000
+++ src/ui_basic/window.cc	2014-11-24 07:32:35 +0000
@@ -320,7 +320,7 @@
 		dst.blit
 			(Point(get_lborder() + get_inner_w() / 2, TP_B_PIXMAP_THICKNESS / 2),
 				UI::g_fh1->render(m_title),
-				CM_UseAlpha,
+				BlendMode::UseAlpha,
 				Align_Center);
 	}
 

=== modified file 'src/ui_fsmenu/loadgame.cc'
--- src/ui_fsmenu/loadgame.cc	2014-11-22 10:18:20 +0000
+++ src/ui_fsmenu/loadgame.cc	2014-11-24 07:32:35 +0000
@@ -36,7 +36,7 @@
 #include "graphic/image_io.h"
 #include "graphic/image_transformations.h"
 #include "graphic/in_memory_image.h"
-#include "graphic/surface.h"
+#include "graphic/texture.h"
 #include "helper.h"
 #include "io/filesystem/layered_filesystem.h"
 #include "logic/game.h"
@@ -317,13 +317,13 @@
 			if (!minimap_path.empty()) {
 				try {
 					// Load the image
-					std::unique_ptr<Surface> surface(
+					std::unique_ptr<Texture> texture(
 								load_image(
 									minimap_path,
 									std::unique_ptr<FileSystem>(g_fs->make_sub_file_system(gamedata.filename)).get()));
 
 					m_minimap_image.reset(new_in_memory_image(std::string(gamedata.filename + minimap_path),
-																			surface.release()));
+																			texture.release()));
 
 					// Scale it
 					double scale = double(m_minimap_w) / m_minimap_image->width();
@@ -337,7 +337,7 @@
 					const Image* resized = ImageTransformations::resize(m_minimap_image.get(), w, h);
 					// keeps our in_memory_image around and give to icon the one
 					// from resize that is handled by the cache. It is still linked to our
-					// surface
+					// texture.
 					m_minimap_icon.set_size(w, h);
 
 					// Center the minimap in the available space

=== modified file 'src/wui/buildingwindow.cc'
--- src/wui/buildingwindow.cc	2014-11-22 10:18:20 +0000
+++ src/wui/buildingwindow.cc	2014-11-24 07:32:35 +0000
@@ -119,7 +119,7 @@
 
 	const Image* dark_frame = ImageTransformations::change_luminosity
 		(&anim.representative_image(building().owner().get_playercolor()), 1.22, true);
-	dst.blit(Point(get_inner_w() / 2, get_inner_h() / 2), dark_frame, CM_UseAlpha, UI::Align_Center);
+	dst.blit(Point(get_inner_w() / 2, get_inner_h() / 2), dark_frame, BlendMode::UseAlpha, UI::Align_Center);
 }
 
 /*

=== modified file 'src/wui/interactive_base.cc'
--- src/wui/interactive_base.cc	2014-11-24 07:32:34 +0000
+++ src/wui/interactive_base.cc	2014-11-24 07:32:35 +0000
@@ -410,7 +410,7 @@
 	if (get_display_flag(dfDebug) || !dynamic_cast<const Game*>(&egbase())) {
 		const std::string gametime(gametimestring(egbase().get_gametime()));
 		const std::string gametime_text = as_uifont(gametime, UI_FONT_SIZE_SMALL);
-		dst.blit(Point(5, 5), UI::g_fh1->render(gametime_text), CM_UseAlpha, UI::Align_TopLeft);
+		dst.blit(Point(5, 5), UI::g_fh1->render(gametime_text), BlendMode::UseAlpha, UI::Align_TopLeft);
 		static boost::format node_format("(%i, %i)");
 
 		const std::string node_text = as_uifont
@@ -418,7 +418,7 @@
 		dst.blit(
 			Point(get_w() - 5, get_h() - 5),
 			UI::g_fh1->render(node_text),
-			CM_UseAlpha,
+			BlendMode::UseAlpha,
 			UI::Align_BottomRight
 		);
 	}
@@ -430,7 +430,7 @@
 			((fps_format %
 			  (1000.0 / m_frametime) % (1000.0 / (m_avg_usframetime / 1000)))
 			 .str(), UI_FONT_SIZE_SMALL);
-		dst.blit(Point(5, 25), UI::g_fh1->render(fps_text), CM_UseAlpha, UI::Align_Left);
+		dst.blit(Point(5, 25), UI::g_fh1->render(fps_text), BlendMode::UseAlpha, UI::Align_Left);
 	}
 }
 

=== modified file 'src/wui/minimap.cc'
--- src/wui/minimap.cc	2014-11-22 11:32:06 +0000
+++ src/wui/minimap.cc	2014-11-24 07:32:35 +0000
@@ -26,7 +26,7 @@
 #include "graphic/in_memory_image.h"
 #include "graphic/minimap_renderer.h"
 #include "graphic/rendertarget.h"
-#include "graphic/surface.h"
+#include "graphic/texture.h"
 #include "logic/map.h"
 #include "wui/interactive_player.h"
 #include "wui/mapviewpixelconstants.h"
@@ -63,15 +63,15 @@
 
 void MiniMap::View::draw(RenderTarget & dst)
 {
-	std::unique_ptr<Surface> surface(
+	std::unique_ptr<Texture> texture(
 	   draw_minimap(m_ibase.egbase(),
 	                m_ibase.get_player(),
 	                (*m_flags) & (MiniMapLayer::Zoom2) ?
 	                   Point((m_viewx - get_w() / 4), (m_viewy - get_h() / 4)) :
 	                   Point((m_viewx - get_w() / 2), (m_viewy - get_h() / 2)),
 	                *m_flags | MiniMapLayer::ViewWindow));
-	// Give ownership of the surface to the new image
-	std::unique_ptr<const Image> im(new_in_memory_image("minimap", surface.release()));
+	// Give ownership of the texture to the new image
+	std::unique_ptr<const Image> im(new_in_memory_image("minimap", texture.release()));
 	dst.blit(Point(), im.get());
 	im.reset();
 }

=== modified file 'src/wui/plot_area.cc'
--- src/wui/plot_area.cc	2014-11-08 14:59:03 +0000
+++ src/wui/plot_area.cc	2014-11-24 07:32:35 +0000
@@ -142,7 +142,7 @@
  */
 void draw_value(const string& value, const RGBColor& color, const Point& pos, RenderTarget & dst) {
 	const Image* pic = UI::g_fh1->render(ytick_text_style(value, color));
-	dst.blit(pos, pic, CM_UseAlpha, UI::Align_CenterRight);
+	dst.blit(pos, pic, BlendMode::UseAlpha, UI::Align_CenterRight);
 }
 
 /**
@@ -223,7 +223,7 @@
 			(xtick_text_style((boost::format("-%u ") % (max_x / how_many_ticks * i)).str()));
 		dst.blit
 			(Point(static_cast<int32_t>(posx), inner_h - space_at_bottom + 10),
-			 xtick, CM_UseAlpha, UI::Align_Center);
+			 xtick, BlendMode::UseAlpha, UI::Align_Center);
 
 		posx -= sub;
 	}
@@ -242,7 +242,7 @@
 
 	//  print the used unit
 	const Image* xtick = UI::g_fh1->render(xtick_text_style(get_unit_name(unit)));
-	dst.blit(Point(2, spacing + 2), xtick, CM_UseAlpha, UI::Align_CenterLeft);
+	dst.blit(Point(2, spacing + 2), xtick, BlendMode::UseAlpha, UI::Align_CenterLeft);
 }
 
 }  // namespace