Merge lp:~nha/widelands/graphics-refactor into lp:widelands

[Nicolai Hähnle]

This merge contains a pretty huge refactoring that attempts to clarify the meaning of surfaces vs. pictures, and enforce it via the C++ type system.

From now on Pictures are things that can act as blit sources, while Surfaces are things that can act as blit destinations. In SDL mode, everything is both a Picture and a Surface; in OpenGL mode, this is not the case.

As a side-effect, this also fixes the scaling of menu backgrounds in OpenGL mode.

It's a pretty huge change, which is why I didn't want to commit it immediately. Some more testing is a good idea, and I didn't want to mess with people who are playing this weekend.

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2010-11-07 22:42:19 +0000
+++ src/CMakeLists.txt	2010-11-29 19:01:16 +0000
@@ -54,7 +54,7 @@
     add_executable (widelands ${GUI_TYPE} main.cc build_info.cc ${WIN32_ICON_O})
   else (DEFINED MINGW)
     add_executable (widelands ${GUI_TYPE} main.cc build_info.cc)
-  endif (DEFINED MINGW) 
+  endif (DEFINED MINGW)
 endif (DEFINED MSVC)
 
 add_library (widelands_all ${WL_SRCS_CC} ${WL_SRCS_H})
@@ -72,7 +72,7 @@
     if (WIN32)
       string(REGEX REPLACE "^.*:" "" sourcenoslash ${sourcenoslash})
     endif (WIN32)
-    get_filename_component(sourcename ${sourcefile} NAME) 
+    get_filename_component(sourcename ${sourcefile} NAME)
     set(stamp ${sourcename}_)
     add_custom_command(
       OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/codecheck_${sourcenoslash}"
@@ -151,7 +151,7 @@
 
   else (DEFINED MSVC)
     target_link_libraries(widelands wsock32)
-  endif (DEFINED MSVC) 
+  endif (DEFINED MSVC)
 endif (WIN32)
 
 install(TARGETS widelands DESTINATION ${WLBUILD_INSTALL_BINDIR} COMPONENT ExecutableFiles)

=== modified file 'src/editor/editorinteractive.cc'
--- src/editor/editorinteractive.cc	2010-11-01 22:30:23 +0000
+++ src/editor/editorinteractive.cc	2010-11-29 19:01:16 +0000
@@ -594,6 +594,7 @@
 	editor.cleanup_objects();
 
 	g_gr->flush(PicMod_Game);
+	g_gr->flush_animations();
 	g_anim.flush();
 }
 

=== modified file 'src/editor/ui_menus/editor_tool_set_terrain_options_menu.cc'
--- src/editor/ui_menus/editor_tool_set_terrain_options_menu.cc	2010-11-01 22:30:23 +0000
+++ src/editor/ui_menus/editor_tool_set_terrain_options_menu.cc	2010-11-29 19:01:16 +0000
@@ -94,7 +94,7 @@
 				pos.y += TEXTURE_HEIGHT + vspacing();
 			}
 
-			PictureID surface;
+			PictureID picture;
 
 			// If offscreen rendering is not available only the terrain (and not
 			// the terrain type) is shown.
@@ -102,11 +102,11 @@
 			//       or implement offscreen rendering for opengl
 			if (g_gr->caps().offscreen_rendering)
 			{
-				//  create a surface for this
-				surface = g_gr->create_picture_surface(64, 64);
+				OffscreenSurfacePtr offscreen = g_gr->create_offscreen_surface(64, 64);
+				picture = g_gr->get_offscreen_picture(offscreen);
 
 				//  get the rendertarget for this
-				RenderTarget & target = *g_gr->get_surface_renderer(surface);
+				RenderTarget target(offscreen);
 
 				//  first, blit the terrain texture
 				target.blit
@@ -144,16 +144,16 @@
 						target.blit(pic, dry);
 				}
 			} else {
-				surface = g_gr->get_picture
+				picture = g_gr->get_picture
 					(PicMod_Game,
 					 g_gr->get_maptexture_data(world.terrain_descr(i).get_texture())
 					 ->get_texture_picture());
 			}
 
 			//  Save this surface, so we can free it later on.
-			m_surfaces.push_back(surface);
+			m_surfaces.push_back(picture);
 
-			UI::Checkbox & cb = *new UI::Checkbox(this, pos, surface);
+			UI::Checkbox & cb = *new UI::Checkbox(this, pos, picture);
 			cb.set_size(TEXTURE_WIDTH + 1, TEXTURE_HEIGHT + 1);
 			cb.set_id(i);
 			cb.set_state(m_tool.is_enabled(i));
@@ -185,9 +185,8 @@
 }
 
 
-Editor_Tool_Set_Terrain_Options_Menu::~Editor_Tool_Set_Terrain_Options_Menu() {
-	container_iterate_const(std::vector<PictureID>, m_surfaces, i)
-		g_gr->free_picture_surface(*i.current);
+Editor_Tool_Set_Terrain_Options_Menu::~Editor_Tool_Set_Terrain_Options_Menu()
+{
 }
 
 

=== modified file 'src/graphic/animation_gfx.h'
--- src/graphic/animation_gfx.h	2010-11-10 20:05:21 +0000
+++ src/graphic/animation_gfx.h	2010-11-29 19:01:16 +0000
@@ -22,23 +22,22 @@
 
 #include "animation.h"
 #include "logic/widelands.h"
+#include "picture_id.h"
 #include "rgbcolor.h"
 
-struct Surface;
-
 struct AnimationGfx { /// The graphics belonging to an animation.
 	AnimationGfx(AnimationData const * data);
 	~AnimationGfx();
 
 	const Point get_hotspot() const throw () {return m_hotspot;}
-	typedef std::vector<Surface *> Frames;
+	typedef std::vector<PictureID> Frames;
 	typedef Frames::size_type Index;
 	Index nr_frames() const
 	{
 		assert((*m_plrframes)[0]); return m_plrframes[0].size();
 	}
 
-	Surface * get_frame
+	const PictureID & get_frame
 		(Index                    const i,
 		 Widelands::Player_Number const player_number,
 		 RGBColor         const * const playercolor)
@@ -56,7 +55,7 @@
 		return m_plrframes[player_number][i];
 	}
 
-	Surface * get_frame(Index const i) const {
+	const PictureID & get_frame(Index const i) const {
 		assert(i < nr_frames());
 		return m_plrframes[0][i];
 	}

=== added file 'src/graphic/compositemode.h'
--- src/graphic/compositemode.h	1970-01-01 00:00:00 +0000
+++ src/graphic/compositemode.h	2010-11-29 19:01:16 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef COMPOSITEMODE_H
+#define COMPOSITEMODE_H
+
+/**
+ * Defines composition operations performed while blitting.
+ */
+enum Composite {
+	/**
+	 * Perform a normal blitting operation that respects the alpha
+	 * channel if present.
+	 */
+	CM_Normal = 0,
+
+	/**
+	 * Perform a solid blit that ignores the alpha channel information.
+	 */
+	CM_Solid,
+
+	/**
+	 * Copy all pixel information, including alpha channel information.
+	 */
+	CM_Copy
+};
+
+#endif // COMPOSITEMODE_H

=== modified file 'src/graphic/font_handler.cc'
--- src/graphic/font_handler.cc	2010-11-01 22:37:46 +0000
+++ src/graphic/font_handler.cc	2010-11-29 19:01:16 +0000
@@ -32,7 +32,6 @@
 #include "rendertarget.h"
 #include "surface.h"
 #include "graphic/render/surface_sdl.h"
-#include "graphic/render/surface_opengl.h"
 
 #include <SDL_image.h>
 #include <SDL_ttf.h>
@@ -96,7 +95,7 @@
 	 Align               const align,
 	 uint32_t            const wrap,
 	 Widget_Cache        const widget_cache,
-	 PictureID         &       widget_cache_id,
+	 PictureID         *       widget_cache_id,
 	 uint32_t            const caret,
 	 bool                const transparent)
 {
@@ -124,20 +123,17 @@
 				m_cache.erase (i);
 			}
 		} else {
-			//not cached, create a new surface
+			//not cached, create a new surface and cache it
 			ci.picture_id =
 				create_text_surface
 					(font, fg, bg, text, align, wrap, 0, caret, transparent);
-			// Now cache it
-			assert(ci.picture_id->surface);
 			g_gr->get_picture_size(ci.picture_id, ci.w, ci.h);
 			ci.f = &font;
 			m_cache.push_front (ci);
 
-			while (m_cache.size() > CACHE_ARRAY_SIZE) {
-				g_gr->free_picture_surface(m_cache.back().picture_id);
+			while (m_cache.size() > CACHE_ARRAY_SIZE)
 				m_cache.pop_back();
-			}
+
 			//Set for alignment and blitting
 			picid = ci.picture_id;
 			w = ci.w;
@@ -145,16 +141,16 @@
 		}
 	} else if (widget_cache == Widget_Cache_Use) {
 		//  Widget gave us an explicit picid.
-		g_gr->get_picture_size(widget_cache_id, w, h);
-		picid = widget_cache_id;
-	} else { // We need to (re)create the picid for the widget.
-		if (widget_cache == Widget_Cache_Update)
-			g_gr->free_picture_surface(widget_cache_id);
-		widget_cache_id =
+		g_gr->get_picture_size(*widget_cache_id, w, h);
+		picid = *widget_cache_id;
+	} else {
+		// We need to (re)create the picid for the widget.
+		// The old picture is freed automatically
+		*widget_cache_id =
 			create_text_surface
 				(font, fg, bg, text, align, wrap, 0, caret, transparent);
-		g_gr->get_picture_size(widget_cache_id, w, h);
-		picid = widget_cache_id;
+		g_gr->get_picture_size(*widget_cache_id, w, h);
+		picid = *widget_cache_id;
 	}
 	do_align(align, dstpoint.x, dstpoint.y, w, h);
 	dst.blit(dstpoint, picid);
@@ -347,14 +343,11 @@
 	TTF_SizeUTF8(&font, text_caret_pos.c_str(), &caret_x, &caret_y);
 	caret_x += LINE_MARGIN;
 
-	Surface * const caret_surf =
-		g_gr->get_picture_surface
-			(g_gr->get_picture(PicMod_Game, "pics/caret.png"));
-
 	//TODO: Implement caret rendering for opengl
 	if (!g_opengl)
 	{
-		upcast(SurfaceSDL, sdlsurf, caret_surf);
+		PictureID caret = g_gr->get_picture(PicMod_Game, "pics/caret.png");
+		upcast(SurfaceSDL, sdlsurf, caret.get());
 		assert(sdlsurf);
 		SDL_Surface * const caret_surf_sdl = sdlsurf->get_sdl_surface();
 
@@ -421,16 +414,13 @@
 	 std::string          text,
 	 int32_t              wrap,
 	 Widget_Cache         widget_cache,
-	 PictureID    &       widget_cache_id,
+	 PictureID    *       widget_cache_id,
 	 bool           const transparent)
 {
 	PictureID picid;
 	if (widget_cache == Widget_Cache_Use)
-		picid = widget_cache_id;
+		picid = *widget_cache_id;
 	else {
-		if (widget_cache == Widget_Cache_Update) {
-			g_gr->free_picture_surface(widget_cache_id);
-		}
 		std::vector<Richtext_Block> blocks;
 		Text_Parser p;
 		p.parse(text, blocks);
@@ -473,19 +463,18 @@
 				img_pos.x = img_surf_w;
 				img_pos.y = 0;
 				if
-					(Surface * const image =
-					 g_gr->get_picture_surface //  Not Font, but Game.
-					 	(g_gr->get_picture(PicMod_Game, img_it->c_str())))
+					(PictureID const image =
+					 	g_gr->get_picture(PicMod_Game, *img_it))
 				{
 					img_surf_h =
 						img_surf_h < static_cast<int32_t>(image->get_h()) ?
 						image->get_h() : img_surf_h;
 					img_surf_w = img_surf_w + image->get_w();
 
-					upcast(SurfaceSDL, sdlsurf, image);
+					upcast(SurfaceSDL, sdlsurf, image.get());
 					if (sdlsurf)
 						rend_cur_images.push_back(sdlsurf->get_sdl_surface());
-
+					// TODO fix this for OpenGL
 				}
 			}
 			SDL_Surface * const block_images =
@@ -701,7 +690,7 @@
 			convert_sdl_surface
 				(*join_sdl_surfaces(wrap, global_h, rend_blocks, bg),
 				 bg, transparent);
-		widget_cache_id = picid;
+		*widget_cache_id = picid;
 	}
 	dst.blit(dstpoint, picid);
 }
@@ -813,11 +802,7 @@
 			(&surface, SDL_SRCCOLORKEY,
 			 SDL_MapRGB(surface.format, bg.r(), bg.g(), bg.b()));
 
-	Surface & surf = g_gr->create_surface(surface, transparent);
-
-	PictureID picid = g_gr->get_picture(PicMod_Font, surf);
-
-	return picid;
+	return g_gr->convert_sdl_surface_to_picture(&surface, transparent);
 }
 
 //Sets dstx and dsty to values for a specified align
@@ -846,15 +831,9 @@
 /*
  * Flushes the cached picture ids
  */
-void Font_Handler::flush_cache() {
-	while (!m_cache.empty()) {
-		g_gr->free_picture_surface (m_cache.front().picture_id);
-		m_cache.pop_front();
-	}
-}
-//Deletes widget controlled surface
-void Font_Handler::delete_widget_cache(PictureID const widget_cache_id) {
-	g_gr->free_picture_surface(widget_cache_id);
+void Font_Handler::flush_cache()
+{
+	m_cache.clear();
 }
 
 //Inserts linebreaks into a text, so it doesn't get bigger than max_width

=== modified file 'src/graphic/font_handler.h'
--- src/graphic/font_handler.h	2010-11-05 19:36:57 +0000
+++ src/graphic/font_handler.h	2010-11-29 19:01:16 +0000
@@ -56,7 +56,7 @@
 		 Align               align           = Align_CenterLeft,
 		 uint32_t            wrap         = std::numeric_limits<uint32_t>::max(),
 		 Widget_Cache        widget_cache    = Widget_Cache_None,
-		 PictureID         & widget_cache_id = g_gr->get_no_picture(),
+		 PictureID         * widget_cache_id = 0,
 		 uint32_t            caret        = std::numeric_limits<uint32_t>::max(),
 		 bool                transparent     = true);
 	void get_size
@@ -79,7 +79,6 @@
 	// from the graphics code before the graphics are flushed,
 	// to make sure that everything is forgotten
 	void flush_cache();
-	void delete_widget_cache(PictureID widget_cache_id);
 	void draw_richtext
 		(RenderTarget &,
 		 RGBColor bg,
@@ -87,7 +86,7 @@
 		 std::string text,
 		 int32_t wrap,
 		 Widget_Cache widget_cache = Widget_Cache_None,
-		 PictureID & widget_cache_id = g_gr->get_no_picture(),
+		 PictureID * widget_cache_id = 0,
 		 bool transparent = true);
 	void get_size_from_cache
 		(PictureID widget_cache_id, uint32_t & w, uint32_t & h);

=== modified file 'src/graphic/graphic.cc'
--- src/graphic/graphic.cc	2010-11-01 23:13:48 +0000
+++ src/graphic/graphic.cc	2010-11-29 19:01:16 +0000
@@ -32,11 +32,13 @@
 #include "io/streamwrite.h"
 
 #include "font_handler.h"
+#include "picture.h"
 #include "rendertarget.h"
 #include "texture.h"
 
 #include "render/surface_sdl.h"
-#include "render/surface_opengl.h"
+#include "render/gl_picture_texture.h"
+#include "render/gl_surface_screen.h"
 
 #include "logic/roadtype.h"
 #include "logic/widelands_fileread.h"
@@ -50,6 +52,7 @@
 
 #include <cstring>
 #include <iostream>
+#include <boost/scoped_array.hpp>
 
 Graphic * g_gr;
 bool g_opengl;
@@ -74,8 +77,6 @@
 	m_update_fullscreen(false),
 	m_roadtextures     (0)
 {
-	m_picturemap.resize(MaxModule);
-
 	// Initialize the table used to create grayed pictures
 	for
 		(uint32_t i = 0, r = 0, g = 0, b = 0;
@@ -150,9 +151,7 @@
 		log("Graphics: FULLSCREEN ENABLED\n");
 
 	// Set rendering capabilities for sdl. They are overwritten if in opengl mode
-	m_caps.resize_surfaces = true;
 	m_caps.offscreen_rendering = true;
-	m_caps.blit_resized = false;
 
 #ifdef USE_OPENGL
 	if (0 != (sdlsurface->flags & SDL_OPENGL)) {
@@ -199,9 +198,7 @@
 			(m_caps.gl.tex_power_of_two?"must have a size power of two\n":
 			 "may have any size\n");
 
-		m_caps.resize_surfaces = false;
 		m_caps.offscreen_rendering = false;
-		m_caps.blit_resized = true;
 	}
 #endif
 
@@ -280,13 +277,16 @@
 	}
 
 	if (g_opengl)
-		m_screen = new SurfaceOpenGL(w, h);
+	{
+		m_screen.reset(new GLSurfaceScreen(w, h));
+	}
 	else
 #endif
 	{
-		m_screen = new SurfaceSDL(*sdlsurface);
+		boost::shared_ptr<SurfaceSDL> screen(new SurfaceSDL(*sdlsurface));
+		screen->set_isscreen(true);
+		m_screen = screen;
 	}
-	m_screen->set_type(SURFACE_SCREEN);
 
 	m_sdl_screen = sdlsurface;
 	m_rendertarget = new RenderTarget(m_screen);
@@ -297,12 +297,11 @@
 */
 Graphic::~Graphic()
 {
-	for (size_t i = 1; i < m_picturemap.size(); ++i)
-		flush(static_cast<PicMod>(i));
-
 	delete m_rendertarget;
-	delete m_screen;
 	delete m_roadtextures;
+
+	// Remove traces of cached pictures
+	UI::g_fh->flush_cache();
 }
 
 /**
@@ -401,33 +400,27 @@
 }
 
 /**
- * Remove all resources (currently pictures) from the given modules.
- * \note flush(0) does nothing <- obviously wrong it deletes a lot!
-*/
-void Graphic::flush(PicMod const module) {
-	// Flush pictures
-
-	//pmit b, e = m_picturemap.end();
-	for (size_t i = 0; i < m_picturemap.size(); ++i) {
-		if (static_cast<PicMod>(i) == module) {
-			m_picturemap[i].clear();
-		}
-	}
-
-	if (!module || module & PicMod_Game) {
-		container_iterate_const(std::vector<Texture *>, m_maptextures, i)
-			delete *i.current;
-		m_maptextures.clear();
-
-		container_iterate_const(std::vector<AnimationGfx *>, m_animations, i)
-			delete *i.current;
-		m_animations.clear();
-
-		delete m_roadtextures;
-		m_roadtextures = 0;
-	}
-
-	if (not module or module & PicMod_UI) // Flush the cached Fontdatas
+ * Clear all cached resources from the given module.
+ *
+ * \note This only removes the cache entries. If the corresonding resources
+ * are still in use somewhere, they will not be freed.
+ */
+void Graphic::flush(PicMod const module)
+{
+	std::vector<std::string> eraselist;
+
+	for (pmit it = m_picturemap.begin(); it != m_picturemap.end(); ++it) {
+		it->second.modules &= ~(1 << module);
+		if (!it->second.modules)
+			eraselist.push_back(it->first);
+	}
+
+	while (!eraselist.empty()) {
+		m_picturemap.erase(eraselist.back());
+		eraselist.pop_back();
+	}
+
+	if (module == PicMod_UI) // Flush the cached Fontdatas
 		UI::g_fh->flush_cache();
 }
 
@@ -440,7 +433,7 @@
 }
 
 
-Surface & Graphic::load_image(std::string const & fname, bool const alpha) {
+PictureID Graphic::load_image(std::string const & fname, bool const alpha) {
 	//log("Graphic::LoadImage(\"%s\")\n", fname.c_str());
 	FileRead fr;
 	SDL_Surface * sdlsurf;
@@ -453,9 +446,7 @@
 	if (!sdlsurf)
 		throw wexception("%s", IMG_GetError());
 
-	Surface & surf = create_surface(*sdlsurf, alpha);
-
-	return surf;
+	return convert_sdl_surface_to_picture(sdlsurf, alpha);
 }
 
 /**
@@ -465,171 +456,197 @@
  *
  * \return 0 (a null-picture) if the picture cannot be loaded.
 */
-PictureID & Graphic::get_picture
+const PictureID & Graphic::get_picture
 	(PicMod const module, const std::string & fname, bool alpha)
 {
 	//  Check if the picture is already loaded.
-	pmit it = m_picturemap[module].find(fname);
+	pmit it = m_picturemap.find(fname);
 
-	if (it != m_picturemap[module].end()) {
-		return it->second;
-	} else {
-		Surface * surf;
+	if (it == m_picturemap.end()) {
+		PictureRec rec;
 
 		try {
-			surf = &load_image(fname, alpha);
+			rec.picture = load_image(fname, alpha);
 			//log("Graphic::get_picture(): loading picture '%s'\n", fname.c_str());
 		} catch (std::exception const & e) {
 			log("WARNING: Could not open %s: %s\n", fname.c_str(), e.what());
 			return get_no_picture();
 		}
-		// Convert the surface accordingly
-
-		// Fill in a free slot in the pictures array
-		Picture & pic = * new Picture();
-		PictureID id = PictureID(&pic);
-		m_picturemap[module].insert(std::make_pair(fname, id));
-
-		assert(pic.fname == 0);
-		pic.fname = strdup(fname.c_str());
-
-		//  FIXME no proper check for NULL return value!
-		assert(pic.fname != 0);
-
-		pic.surface = surf;
-
-		it = m_picturemap[module].find(fname);
+
+		it = m_picturemap.insert(std::make_pair(fname, rec)).first;
 	}
 
-	it->second->module = module;
-
-	return it->second;
-}
-
-PictureID Graphic::get_picture
-	(PicMod const module, Surface & surf, std::string const & fname)
-{
-	Picture & pic = * new Picture();
-	PictureID id = PictureID(&pic);
-	m_picturemap[module].insert(std::make_pair(fname, id));
-
-	pic.module    = module;
-	pic.surface   = &surf;
-
-	if (fname.size() != 0) {
-		assert(pic.fname == 0);
-		pic.fname = strdup(fname.c_str());
-	} else
-		pic.fname = 0;
-
-	//return m_picturemap.find(fname);
-	return id;
-}
-
-PictureID & Graphic::get_no_picture() const {
-	static PictureID invalid = PictureID(new Picture());
-	return invalid;
+	it->second.modules |= 1 << module;
+	return it->second.picture;
+}
+
+/**
+ * Add the given picture to the cache under the given name.
+ *
+ * This overwrites pre-existing cache entries, if any.
+ */
+void Graphic::add_picture_to_cache(PicMod module, const std::string & name, PictureID pic)
+{
+	PictureRec rec;
+	rec.picture = pic;
+	rec.modules = 1 << module;
+	m_picturemap.insert(std::make_pair(name, rec));
+}
+
+/**
+ * \return an empty, invalid, null picture
+ */
+const PictureID & Graphic::get_no_picture() const
+{
+	return IPicture::null();
 }
 
 /**
  * Produces a resized version of the specified picture
  *
- * This might not work with the renderer. Check g_gr->caps().resize_surfaces
- * to be sure the resizing is possible.
  * Might return same id if dimensions are the same
  */
 PictureID Graphic::get_resized_picture
-	(PictureID index,
+	(PictureID src,
 	 uint32_t const w, uint32_t const h,
 	 ResizeMode const mode)
 {
-	// Resizing is not possible with opengl surfaces
-	if (g_opengl)
-		g_gr->get_no_picture();
-
-	Surface * const orig = index->surface;
-	if (orig->get_w() == w and orig->get_h() == h)
-		return index;
-
-	uint32_t width = w;
-	uint32_t height = h;
-
-	if (mode != ResizeMode_Loose) {
-		const double ratio_x = double(w) / orig->get_w();
-		const double ratio_y = double(h) / orig->get_h();
-
-		//  if proportions are to be kept, recalculate width and height
-		if ((ratio_x - ratio_y) > 0.00001) { //  if not equal
-			double ratio = 0;
-
-			if (ResizeMode_Clip == mode)
-				ratio = std::max (ratio_x, ratio_y);
-			else if (ResizeMode_LeaveBorder == mode)
-				ratio = std::max (ratio_x, ratio_y);
-			else // average
-				ratio = (ratio_x + ratio_y) / 2;
-
-			width = uint32_t(orig->get_w() * ratio);
-			height = uint32_t(orig->get_h() * ratio);
+	if (src->get_w() == w and src->get_h() == h)
+		return src;
+
+	// First step: compute scaling factors
+	Rect srcrect;
+	Rect destrect;
+
+	if (mode == ResizeMode_Loose) {
+		srcrect = Rect(Point(0, 0), src->get_w(), src->get_h());
+		destrect = Rect(Point(0, 0), w, h);
+	} else {
+		const double ratio_x = double(w) / src->get_w();
+		const double ratio_y = double(h) / src->get_h();
+		double ratio;
+
+		if (ResizeMode_Clip == mode)
+			ratio = std::max(ratio_x, ratio_y);
+		else if (ResizeMode_LeaveBorder == mode)
+			ratio = std::min(ratio_x, ratio_y);
+		else // average
+			ratio = (ratio_x + ratio_y) / 2;
+
+		uint32_t fullwidth(src->get_w() * ratio);
+		uint32_t fullheight(src->get_h() * ratio);
+
+		if (fullwidth <= w) {
+			srcrect.x = 0;
+			srcrect.w = src->get_w();
+			destrect.x = (w - fullwidth) / 2;
+			destrect.w = fullwidth;
+		} else {
+			srcrect.w = std::min(src->get_w(), uint32_t(w / ratio));
+			srcrect.x = (src->get_w() - srcrect.w) / 2;
+			destrect.x = 0;
+			destrect.w = w;
+		}
+
+		if (fullheight <= h) {
+			srcrect.y = 0;
+			srcrect.h = src->get_h();
+			destrect.y = (h - fullheight) / 2;
+			destrect.h = fullheight;
+		} else {
+			srcrect.h = std::min(src->get_h(), uint32_t(h / ratio));
+			srcrect.y = (src->get_h() - srcrect.h) / 2;
+			destrect.y = 0;
+			destrect.h = h;
 		}
 	}
 
-	PictureID pic = g_gr->create_picture_surface(w, h);
+	// Second step: get source material
+	SDL_Surface * srcsdl = 0;
+	bool free_source = true;
 
-	if (mode == ResizeMode_Loose || (width == w && height == h)) {
-		if (g_opengl)
+	if (upcast(SurfaceSDL, srcsurf, src.get())) {
+		if
+			(srcrect.x != 0 || srcrect.w != uint32_t(srcsurf->get_w()) ||
+			 srcrect.y != 0 || srcrect.h != uint32_t(srcsurf->get_h()))
 		{
+			const SDL_PixelFormat & fmt = *srcsurf->get_sdl_surface()->format;
+			srcsdl = SDL_CreateRGBSurface
+				(SDL_SWSURFACE, srcrect.w, srcrect.h,
+				 fmt.BitsPerPixel, fmt.Rmask, fmt.Gmask, fmt.Bmask, fmt.Amask);
+			SDL_Rect srcrc = {srcrect.x, srcrect.y, srcrect.w, srcrect.h};
+			SDL_Rect dstrc = {0, 0, 0, 0};
+			bool alpha = srcsurf->get_sdl_surface()->flags & SDL_SRCALPHA;
+			uint8_t alphaval = srcsurf->get_sdl_surface()->format->alpha;
+			SDL_SetAlpha(srcsurf->get_sdl_surface(), 0, 0);
+			SDL_BlitSurface(srcsurf->get_sdl_surface(), &srcrc, srcsdl, &dstrc);
+			SDL_SetAlpha(srcsurf->get_sdl_surface(), alpha ? SDL_SRCALPHA : 0, alphaval);
 		} else {
-			dynamic_cast<SurfaceSDL *>
-				(pic->surface)->set_sdl_surface(*resize(index, w, h));
+			srcsdl = srcsurf->get_sdl_surface();
+			free_source = false;
 		}
 	} else {
-		SurfaceSDL src(*resize(index, width, height));
-
-		// apply rectangle by adjusted size
-		Rect srcrc;
-		srcrc.w = std::min(w, width);
-		srcrc.h = std::min(h, height);
-		srcrc.x = (width - srcrc.w) / 2;
-		srcrc.y = (height - srcrc.h) / 2;
-
-
-		g_gr->get_surface_renderer(pic)->blitrect //  Get the rendertarget
-			(Point((w - srcrc.w) / 2, (h - srcrc.h) / 2),
-			 get_picture(index->module, src), srcrc);
-	}
-	return pic;
+		srcsdl = extract_sdl_surface(src->pixelaccess(), srcrect);
+	}
+
+	// Third step: perform the zoom and placement
+	SDL_Surface * zoomed = zoomSurface
+		(srcsdl, double(destrect.w) / srcsdl->w, double(destrect.h) / srcsdl->h, 1);
+	if (free_source)
+		SDL_FreeSurface(srcsdl);
+
+	if (uint32_t(zoomed->w) != w || uint32_t(zoomed->h) != h) {
+		const SDL_PixelFormat & fmt = *zoomed->format;
+		SDL_Surface * placed = SDL_CreateRGBSurface
+			(SDL_SWSURFACE, w, h,
+			 fmt.BitsPerPixel, fmt.Rmask, fmt.Gmask, fmt.Bmask, fmt.Amask);
+		SDL_Rect srcrc = {0, 0, zoomed->w, zoomed->h};
+		SDL_Rect dstrc = {destrect.x, destrect.y};
+		SDL_SetAlpha(zoomed, 0, 0);
+		SDL_BlitSurface(zoomed, &srcrc, placed, &dstrc);
+		SDL_FreeSurface(zoomed);
+		zoomed = placed;
+	}
+
+	return convert_sdl_surface_to_picture(zoomed);
 }
 
 /**
- * Produces a resized version of the specified picture. This works only for
- * SDL rendering. Check g_gr->caps().resize_surfaces before calling this
- * function.
- *
- * \param index position of the source picture in the stack
- * \param w target width
- * \param h target height
- * \return resized version of picture
+ * Create and return an \ref SDL_Surface that contains the given sub-rectangle
+ * of the given pixel region.
  */
-SDL_Surface * Graphic::resize
-	(const PictureID index, uint32_t const w, uint32_t const h)
+SDL_Surface * Graphic::extract_sdl_surface(IPixelAccess & pix, Rect srcrect)
 {
-	Surface & orig = *g_gr->get_picture_surface(index);
-
-	if (g_opengl)
-		throw wexception("Graphic::resize() not yet implemented for opengl");
-	else
-	{
-		SurfaceSDL & origsdl = dynamic_cast<SurfaceSDL &>(orig);
-		return
-			zoomSurface
-				(origsdl.get_sdl_surface(),
-				 double(w) / orig.get_w(), double(h) / orig.get_h(),
-				 1);
+	assert(srcrect.x >= 0);
+	assert(srcrect.y >= 0);
+	assert(srcrect.x + srcrect.w <= pix.get_w());
+	assert(srcrect.y + srcrect.h <= pix.get_h());
+
+	const SDL_PixelFormat & fmt = pix.format();
+	SDL_Surface * dest = SDL_CreateRGBSurface
+		(SDL_SWSURFACE, srcrect.w, srcrect.h,
+		 fmt.BitsPerPixel, fmt.Rmask, fmt.Gmask, fmt.Bmask, fmt.Amask);
+
+	pix.lock(IPixelAccess::Lock_Normal);
+	SDL_LockSurface(dest);
+
+	uint32_t srcpitch = pix.get_pitch();
+	uint32_t rowsize = srcrect.w * fmt.BytesPerPixel;
+	uint8_t * srcpix = pix.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) {
+		memcpy(dstpix, srcpix, rowsize);
+		srcpix += srcpitch;
+		dstpix += dest->pitch;
 	}
+
+	SDL_UnlockSurface(dest);
+	pix.unlock(IPixelAccess::Unlock_NoChange);
+
+	return dest;
 }
 
-
 /**
  * Stores the picture size in pw and ph.
  * Throws an exception if the picture doesn't exist.
@@ -637,20 +654,27 @@
 void Graphic::get_picture_size
 	(const PictureID & pic, uint32_t & w, uint32_t & h) const
 {
-	assert (pic->surface);
-	Surface & bmp = *pic->surface;
-
-	w = bmp.get_w();
-	h = bmp.get_h();
-}
-
-/**
- * Saves a surface to a png. This can be a file or part of a stream.
+	w = pic->get_w();
+	h = pic->get_h();
+}
+
+/**
+ * This is purely a convenience function intended to allow casting
+ * pointers without including a whole bunch of headers.
+ */
+PictureID Graphic::get_offscreen_picture(OffscreenSurfacePtr surface) const
+{
+	return surface;
+}
+
+
+/**
+ * Saves a pixel region to a png. This can be a file or part of a stream.
  *
  * @param surf The Surface to save
  * @param sw a StreamWrite where the png is written to
  */
-void Graphic::save_png(Surface & surf, StreamWrite * sw) const
+void Graphic::save_png(IPixelAccess & pix, StreamWrite * sw) const
 {
 	// Save a png
 	png_structp png_ptr =
@@ -686,7 +710,7 @@
 
 	// Fill info struct
 	png_set_IHDR
-		(png_ptr, info_ptr, surf.get_w(), surf.get_h(),
+		(png_ptr, info_ptr, pix.get_w(), pix.get_h(),
 		 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
 		 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
@@ -701,64 +725,31 @@
 	png_set_packing(png_ptr);
 
 	{
-		uint32_t surf_w = surf.get_w();
-		uint32_t surf_h = surf.get_h();
+		uint32_t surf_w = pix.get_w();
+		uint32_t surf_h = pix.get_h();
 		uint32_t row_size = 4 * surf_w;
 
-		png_bytep rowb = 0;
-		png_bytep rowp = 0;
+		boost::scoped_array<png_byte> row(new png_byte[row_size]);
 
 		//Write each row
-		SDL_PixelFormat * fmt;
-		upcast(SurfaceSDL, sdlsurf, &surf);
-#ifdef USE_OPENGL
-		upcast(SurfaceOpenGL, oglsurf, &surf);
-#endif
-		if (sdlsurf)
-		{
-			fmt = const_cast<SDL_PixelFormat *>(&sdlsurf->format());
-			rowb = (new png_byte[row_size]);
-			if (!rowb)
-				throw wexception("Out of memory.");
-		}
-#ifdef USE_OPENGL
-		else if (oglsurf) {
-			oglsurf->lock();
-			fmt = 0;
-		}
-#endif
-		else
-			return;
-
+		const SDL_PixelFormat & fmt = pix.format();
+		pix.lock(IPixelAccess::Lock_Normal);
 
 		// Write each row
 		for (uint32_t y = 0; y < surf_h; ++y) {
-			rowp = rowb;
-			if (sdlsurf)
-				for (uint32_t x = 0; x < surf_w; rowp += 4, ++x)
-					SDL_GetRGBA
-						(sdlsurf->get_pixel(x, y),
-						 fmt,
-						 rowp + 0, rowp + 1, rowp + 2, rowp + 3);
-#ifdef USE_OPENGL
-			else if (oglsurf) {
-				rowb = static_cast<png_bytep>
-					(oglsurf->get_pixels() +
-					 oglsurf->get_pitch() * (surf_h - y - 1));
+			for (uint32_t x = 0; x < surf_w; ++x) {
+				RGBAColor color;
+				color.set(fmt, pix.get_pixel(x, y));
+				row[4 * x] = color.r;
+				row[4 * x + 1] = color.g;
+				row[4 * x + 2] = color.b;
+				row[4 * x + 3] = color.a;
 			}
-#endif
-			else
-				throw wexception("Try to save save_png with unknown surface\n");
 
-			png_write_row(png_ptr, rowb);
+			png_write_row(png_ptr, row.get());
 		}
-#ifdef USE_OPENGL
-		if (oglsurf)
-			oglsurf->unlock();
-		else
-#endif
-			if (sdlsurf)
-				delete rowb;
+
+		pix.unlock(IPixelAccess::Unlock_NoChange);
 	}
 
 	// End write
@@ -767,267 +758,175 @@
 }
 
 /**
-* Saves a PictureID to a png. This can be a file or part of a stream. This
-* function retrieves the Surface for the PictureID and calls
-* save_png(Surface, StreamWrite)
-*
-* @param surf The Surface to save
-* @param sw a StreamWrite where the png is written to
-*/
+ * Saves a surface to a png. This can be a file or part of a stream.
+ *
+ * @param surf The Surface to save
+ * @param sw a StreamWrite where the png is written to
+ */
+void Graphic::save_png(SurfacePtr surf, StreamWrite * sw) const
+{
+	save_png(surf->pixelaccess(), sw);
+}
+
+/**
+ * Saves a PictureID to a png. This can be a file or part of a stream. This
+ * function retrieves the Surface for the PictureID and calls
+ * save_png(Surface, StreamWrite)
+ *
+ * @param surf The Surface to save
+ * @param sw a StreamWrite where the png is written to
+ */
 void Graphic::save_png(const PictureID & pic_index, StreamWrite * sw) const
 {
-	Surface & surf = const_cast<Surface &>(*get_picture_surface(pic_index));
-	save_png(surf, sw);
-}
-
-/**
- * Create a offscreen surface of specified size and return as PictureID.
- * The surface is put into a normal slot in the picture array so the surface
- * can be used in normal blit() operations. A RenderTarget for the surface can
- * be obtained using get_surface_renderer().
- * \note Surfaces do not belong to a module and must be freed explicitly.
- *
- * @param w width of the new surface
- * @param h height of the new surface
- * @param alpha if true the surface is created with alpha channel
- * @return PictureID of the new created offscreen surface
-*/
-PictureID Graphic::create_picture_surface(int32_t w, int32_t h, bool alpha)
-{
-	//log(" Graphic::create_picture_surface(%d, %d)\n", w, h);
-	Surface & surf = create_surface(w, h, alpha);
-
-	Picture & pic = *new Picture();
-	PictureID id = PictureID(&pic);
-	m_picturemap[PicSurface].insert(std::make_pair("", id));
-
-	pic.module    = PicSurface; // mark as surface
-	pic.surface   = &surf;
-	assert(pic.rendertarget == 0);
-	pic.rendertarget = new RenderTarget(pic.surface);
-
-	return id;
-}
-
-/**
- * Create a Surface from a SDL_Surface. This creates a Surface for OpenGL or
- * Software rendering depending on the actual setting. The SDL_Surface must
- * not be used after calling this. Surface takes care of the SDL_Surface.
- *
- * @param surf a SDL_Surface from which the Surface will be created
+	save_png(pic_index->pixelaccess(), sw);
+}
+
+/**
+ * Create a Picture from an SDL_Surface.
+ *
+ * @param surf a SDL_Surface from which the Surface will be created; this function
+ * takes ownership of surf
  * @param alpha if true the surface is created with alpha channel
  * @return the new Surface created from the SDL_Surface
  */
-Surface & Graphic::create_surface(SDL_Surface & surf, bool alpha)
+PictureID Graphic::convert_sdl_surface_to_picture(SDL_Surface * surf, bool alpha)
 {
 	if (g_opengl)
 	{
 #ifdef USE_OPENGL
-		return *new SurfaceOpenGL(surf);
+		return PictureID(new GLPictureTexture(surf));
 #endif
 	} else {
 		SDL_Surface * surface;
 		if (alpha)
-			surface = SDL_DisplayFormatAlpha(&surf);
-		else
-			surface = SDL_DisplayFormat(&surf);
-		SDL_FreeSurface(&surf);
-		return *new SurfaceSDL(*surface);
-	}
-}
-
-/**
-* Create a Surface from an other Surface. This makes a copy of a Surface.
-*
-* @param surf the surface which will be copied to the new surface
-* @param alpha if true the surface is created with alpha channel
-* @return the new Surface
-*/
-Surface & Graphic::create_surface(Surface & surf, bool alpha)
-{
-	upcast(SurfaceSDL, sdlsurf, &surf);
-	if (sdlsurf)
-	{
-		if (alpha)
-			return
-				*new SurfaceSDL
-					(*SDL_DisplayFormatAlpha(sdlsurf->get_sdl_surface()));
-		else
-			return
-				*new SurfaceSDL
-					(*SDL_DisplayFormat(sdlsurf->get_sdl_surface()));
-	}
-	else
-	{
-		Surface & tsurf = create_surface(surf.get_w(), surf.get_h());
-
-		surf.lock();
-		tsurf.lock();
-		for (unsigned int x = 0; x < surf.get_w(); x++)
-			for (unsigned int y = 0; y < surf.get_h(); y++)
-			{
-				tsurf.set_pixel(x, y, surf.get_pixel(x, y));
-			}
-		surf.unlock();
-		tsurf.unlock();
-
-		return tsurf;
-	}
-}
-
-/**
-* Create a empty offscreen surface of specified size.
-*
-* @param w width of the new surface
-* @param h height of the new surface
-* @param alpha if true the surface is created with alpha channel
-* @return the new created surface
-*/
-Surface & Graphic::create_surface(int32_t w, int32_t h, bool alpha)
-{
-	if (g_opengl)
-	{
-#ifdef USE_OPENGL
-		return *new SurfaceOpenGL(w, h);
-#endif
-	} else {
-		const SDL_PixelFormat & format = m_screen->format();
-		SDL_Surface & tsurf = *SDL_CreateRGBSurface
-			(SDL_SWSURFACE,
-			 w, h,
-			 format.BitsPerPixel,
-			 format.Rmask, format.Gmask, format.Bmask, format.Amask);
-		if (alpha) {
-			SDL_Surface & surf = *SDL_DisplayFormatAlpha(&tsurf);
-			SDL_FreeSurface(&tsurf);
-			return *new SurfaceSDL(surf);
-		}
-		return *new SurfaceSDL(tsurf);
-	}
-}
-
-/**
- * Free the given surface.
- * Unlike normal pictures, surfaces are not freed by flush().
- *
- * @param picid the PictureID ot to be freed
-*/
-void Graphic::free_picture_surface(const PictureID & picid) {
-	if
-		(picid->module != PicMod_Font &&
-		 picid->module != PicSurface)
-	{
-		log
-			("Graphic::free_surface ignoring free of %u %s\n",
-			 picid->module, picid->fname);
-		return;
-	}
-	assert(picid->module == PicMod_Font || picid->module == PicSurface);
-
-	delete picid->surface;
-	picid->surface = 0;
-	delete picid->rendertarget;
-	picid->rendertarget = 0;
-	delete picid->fname;
-	picid->fname = 0;
-
-	container_iterate(Picturemap, m_picturemap[picid->module], it)
-		if (it.current->second == picid) {
-			m_picturemap[picid->module].erase(it.current);
-			break;
-		}
-}
-
-/**
-* create a grayed version.
-*
-* @param picid the PictureID ot to grayed out
-* @return the gray version of the picture
-*/
-PictureID Graphic::create_grayed_out_pic(const PictureID & picid) {
-	if (picid != get_no_picture()) {
-		Surface & s = create_surface(*get_picture_surface(picid), true);
-#ifdef USE_OPENGL
-		upcast(SurfaceOpenGL, gl_dest, &s);
-		upcast(SurfaceOpenGL, gl_src, get_picture_surface(picid));
-#endif
-		upcast(SurfaceSDL, sdl_s, &s);
-		SDL_PixelFormat const * format = 0;
-		if (sdl_s)
-			format = &(sdl_s->format());
-		uint32_t const w = s.get_w(), h = s.get_h();
-#ifdef USE_OPENGL
-		if (gl_src)
-			gl_src->lock();
-#endif
-		s.lock();
-		for (uint32_t y = 0; y < h; ++y)
-			for (uint32_t x = 0; x < w; ++x) {
-				uint8_t r, g, b, a;
-#ifdef USE_OPENGL
-				if (gl_src)
-				{
-					uint32_t pixel = gl_src->get_pixel(x, y);
-					r = pixel & 0xFF;
-					g = (pixel & 0xFF00) >> 8;
-					b = (pixel & 0xFF0000) >> 16;
-					a = (pixel & 0xFF000000) >> 24;
-				} else
-#endif
-				//  FIXME need for const_cast is SDL bug #421
-					SDL_GetRGBA
-						(sdl_s->get_pixel(x, y),
-						 const_cast<SDL_PixelFormat *>(format), &r, &g, &b, &a);
-
-				//  Halve the opacity to give some difference for pictures that are
-				//  grayscale to begin with.
-				a >>= 1;
-
-				uint8_t const gray =
-					(luminance_table_r[r] +
-					 luminance_table_g[g] +
-					 luminance_table_b[b] +
-					 8388608U) //  compensate for truncation:  .5 * 2^24
-					>> 24;
-
-				// NOTE const_cast is needed for SDL-1.2 older than revision 3008
-#ifdef USE_OPENGL
-				if (gl_dest)
-				{
-					gl_dest->set_pixel(x, y, g + (g << 8) + (g << 16) + (a << 24));
-				} else
-#endif
-					sdl_s->set_pixel
-						(x, y,
-						 SDL_MapRGBA
-						 	(const_cast<SDL_PixelFormat *>(format),
-						 	 gray, gray, gray, a));
-
-			}
-		s.unlock();
-#ifdef USE_OPENGL
-		if (gl_src)
-			gl_src->unlock();
-#endif
-		return get_picture(PicSurface, s);
-	} else
+			surface = SDL_DisplayFormatAlpha(surf);
+		else
+			surface = SDL_DisplayFormat(surf);
+		SDL_FreeSurface(surf);
+		return PictureID(new SurfaceSDL(*surface));
+	}
+}
+
+/**
+ * Create a empty offscreen surface of specified size.
+ *
+ * @param w width of the new surface
+ * @param h height of the new surface
+ * @param alpha if true the surface is created with alpha channel
+ * @return the new created surface
+ */
+OffscreenSurfacePtr Graphic::create_offscreen_surface(int32_t w, int32_t h, bool alpha)
+{
+#ifdef USE_OPENGL
+	if (g_opengl)
+	{
+
+		throw wexception("OpenGL mode does not support offscreen surfaces");
+	}
+	else
+#endif
+	{
+		const SDL_PixelFormat & format = *m_sdl_screen->format;
+		SDL_Surface & tsurf = *SDL_CreateRGBSurface
+			(SDL_SWSURFACE,
+			 w, h,
+			 format.BitsPerPixel,
+			 format.Rmask, format.Gmask, format.Bmask, format.Amask);
+		if (alpha) {
+			SDL_Surface & surf = *SDL_DisplayFormatAlpha(&tsurf);
+			SDL_FreeSurface(&tsurf);
+			return OffscreenSurfacePtr(new SurfaceSDL(surf));
+		}
+		return OffscreenSurfacePtr(new SurfaceSDL(tsurf));
+	}
+}
+
+/**
+ * Create a picture with initially undefined contents.
+ *
+ * Use \ref IPicture::pixelaccess to upload image data afterwards.
+ *
+ * @param w width of the new surface
+ * @param h height of the new surface
+ * @param alpha if true the surface is created with alpha channel
+ * @return the new created surface
+ */
+PictureID Graphic::create_picture(int32_t w, int32_t h, bool alpha)
+{
+#ifdef USE_OPENGL
+	if (g_opengl)
+	{
+		return PictureID(new GLPictureTexture(w, h));
+	}
+	else
+#endif
+	{
+		const SDL_PixelFormat & format = *m_sdl_screen->format;
+		SDL_Surface & tsurf = *SDL_CreateRGBSurface
+			(SDL_SWSURFACE,
+			 w, h,
+			 format.BitsPerPixel,
+			 format.Rmask, format.Gmask, format.Bmask, format.Amask);
+		if (alpha) {
+			SDL_Surface & surf = *SDL_DisplayFormatAlpha(&tsurf);
+			SDL_FreeSurface(&tsurf);
+			return OffscreenSurfacePtr(new SurfaceSDL(surf));
+		}
+		return PictureID(new SurfaceSDL(tsurf));
+	}
+}
+
+
+/**
+ * Create a grayed version of the given picture.
+ *
+ * @param picid the PictureID ot to grayed out
+ * @return the gray version of the picture
+ */
+PictureID Graphic::create_grayed_out_pic(const PictureID & picid)
+{
+	if (!picid || !picid->valid())
 		return get_no_picture();
-}
-
-
-/**
- * Returns the RenderTarget for the given surface
-*/
-RenderTarget * Graphic::get_surface_renderer(const PictureID & pic) {
-	//assert(pic < m_pictures.size());
-	//  assert(m_pictures[pic].module == 0xff); fails showing terrains in editor
-
-	RenderTarget & rt = *pic->rendertarget;
-
-	rt.reset();
-
-	return &rt;
-}
+
+	IPixelAccess & origpix = picid->pixelaccess();
+	uint32_t w = picid->get_w();
+	uint32_t h = picid->get_h();
+	const SDL_PixelFormat & origfmt = origpix.format();
+
+	PictureID destpicture = create_picture(w, h, origfmt.Amask);
+	IPixelAccess & destpix = destpicture->pixelaccess();
+	const SDL_PixelFormat & destfmt = destpix.format();
+
+	origpix.lock(IPixelAccess::Lock_Normal);
+	destpix.lock(IPixelAccess::Lock_Discard);
+	for (uint32_t y = 0; y < h; ++y) {
+		for (uint32_t x = 0; x < w; ++x) {
+			RGBAColor color;
+
+			color.set(origfmt, origpix.get_pixel(x, y));
+
+			//  Halve the opacity to give some difference for pictures that are
+			//  grayscale to begin with.
+			color.a >>= 1;
+
+			uint8_t const gray =
+				(luminance_table_r[color.r] +
+				 luminance_table_g[color.g] +
+				 luminance_table_b[color.b] +
+				 8388608U) //  compensate for truncation:  .5 * 2^24
+				>> 24;
+
+			color.r = color.g = color.b = gray;
+
+			destpix.set_pixel(x, y, color.map(destfmt));
+		}
+	}
+	origpix.unlock(IPixelAccess::Unlock_NoChange);
+	destpix.unlock(IPixelAccess::Unlock_Update);
+
+	return destpicture;
+}
+
 
 /**
  * Creates a terrain texture.
@@ -1046,7 +945,7 @@
 {
 	try {
 		m_maptextures.push_back
-			(new Texture(fnametempl, frametime, m_screen->format()));
+			(new Texture(fnametempl, frametime, *m_sdl_screen->format));
 	} catch (std::exception const & e) {
 		log("Failed to load maptexture %s: %s\n", &fnametempl, e.what());
 		return 0;
@@ -1123,10 +1022,10 @@
 		w = h = 0;
 	} else {
 		// Get the frame and its data. Ignore playerclrs.
-		Surface const & frame =
-			*gfx->get_frame((time / data->frametime) % gfx->nr_frames());
-		w = frame.get_w();
-		h = frame.get_h();
+		const PictureID & frame =
+			gfx->get_frame((time / data->frametime) % gfx->nr_frames());
+		w = frame->get_w();
+		h = frame->get_h();
 	}
 }
 
@@ -1137,7 +1036,7 @@
 {
 	log("Save screenshot to %s\n", &fname);
 	StreamWrite * sw = g_fs->OpenStreamWrite(std::string(&fname));
-	save_png(*m_screen, sw);
+	save_png(m_screen, sw);
 	delete sw;
 }
 
@@ -1163,21 +1062,6 @@
 	static_cast<StreamWrite *>(png_get_io_ptr(png_ptr))->Flush();
 }
 
-
-/**
-* Returns the bitmap that belongs to the given picture ID.
-* May return 0 if the given picture does not exist.
-*/
-Surface * Graphic::get_picture_surface(const PictureID & id)
-{
-	return id->surface;
-}
-
-const Surface * Graphic::get_picture_surface(const PictureID & id) const
-{
-	return id->surface;
-}
-
 /**
  * Retrieve the animation with the given number.
  *
@@ -1210,7 +1094,7 @@
  * if not done yet.
  * \return The road texture
 */
-Surface * Graphic::get_road_texture(int32_t const roadtex)
+PictureID Graphic::get_road_texture(int32_t const roadtex)
 {
 	if (not m_roadtextures) {
 		// Load the road textures
@@ -1223,7 +1107,6 @@
 	}
 
 	return
-		get_picture_surface
-			(roadtex == Widelands::Road_Normal ?
-			 m_roadtextures->pic_road_normal : m_roadtextures->pic_road_busy);
+		(roadtex == Widelands::Road_Normal ?
+		 m_roadtextures->pic_road_normal : m_roadtextures->pic_road_busy);
 }

=== modified file 'src/graphic/graphic.h'
--- src/graphic/graphic.h	2010-11-15 18:25:31 +0000
+++ src/graphic/graphic.h	2010-11-29 19:01:16 +0000
@@ -21,8 +21,8 @@
 #define GRAPHIC_H
 
 #include "animation_gfx.h"
-#include "picture.h"
 #include "picture_id.h"
+#include "surfaceptr.h"
 #include "rect.h"
 
 #include <png.h>
@@ -41,8 +41,7 @@
 
 namespace UI {struct ProgressWindow;}
 
-struct Surface;
-class Texture;
+struct IPixelAccess;
 struct RenderTarget;
 struct Graphic;
 struct Road_Textures;
@@ -84,15 +83,29 @@
 {
 	/// The renderer allows rendering (blit, draw_line) to offscreen surfaces
 	bool offscreen_rendering;
-	/// It is possible to resize surfaces with get_resized_picture()
-	bool resize_surfaces;
-	/// It is possible to resize surfaces while bliting
-	bool blit_resized;
 	/// The capabilities of the opengl hardware and drive
 	GLCaps gl;
 };
 
 /**
+ * Picture caches (modules).
+ *
+ * \ref Graphic maintains a cache of \ref PictureID s to avoid continuous re-loading of
+ * pictures that may not be referenced all the time (e.g. UI elements).
+ *
+ * This cache is separated into different modules, and can be flushed per-module.
+ */
+enum PicMod {
+	PicMod_UI = 0,
+	PicMod_Menu,
+	PicMod_Game,
+
+	// Must be last
+	PicMod_Last
+};
+
+
+/**
  * A renderer to get pixels to a 16bit framebuffer.
  *
  * Picture IDs can be allocated using \ref get_picture() and used in
@@ -102,8 +115,7 @@
  * graphics system is unloaded, or when \ref flush() is called with the
  * appropriate module flag; the user can request to flush one single picture
  * alone, but this is only used (and useful) in the editor.
-*/
-
+ */
 struct Graphic {
 	Graphic
 		(int32_t w, int32_t h, int32_t bpp,
@@ -124,31 +136,26 @@
 
 	void flush(PicMod module);
 	void flush_animations();
-	Surface & load_image(std::string const &, bool alpha = false);
-	PictureID & get_picture(PicMod, std::string const &, bool alpha = true)
+	PictureID load_image(std::string const &, bool alpha = false);
+	const PictureID & get_picture(PicMod, std::string const &, bool alpha = true)
 		__attribute__ ((pure));
-	PictureID get_picture
-		(PicMod module, Surface &, const std::string & name = "");
-	//__attribute__ ((pure));
-	PictureID & get_no_picture() const;
-
-	Surface * get_picture_surface(const PictureID & id);
-	const Surface * get_picture_surface(const PictureID & id) const;
+	void add_picture_to_cache(PicMod, const std::string &, PictureID);
+	const PictureID & get_no_picture() const;
 
 	void get_picture_size
 		(const PictureID & pic, uint32_t & w, uint32_t & h) const;
+	PictureID get_offscreen_picture(OffscreenSurfacePtr surface) const;
 
 	void save_png(const PictureID &, StreamWrite *) const;
-	void save_png(Surface & surf, StreamWrite *) const;
-
-	PictureID create_picture_surface(int32_t w, int32_t h, bool alpha = false);
-	Surface & create_surface(SDL_Surface &, bool alpha = false);
-	Surface & create_surface(Surface &, bool alpha = false);
-	Surface & create_surface(int32_t w, int32_t h, bool alpha = false);
-	void free_picture_surface(const PictureID & pic);
+	void save_png(SurfacePtr surf, StreamWrite *) const;
+	void save_png(IPixelAccess & pix, StreamWrite *) const;
+
+	PictureID convert_sdl_surface_to_picture(SDL_Surface *, bool alpha = false);
+
+	OffscreenSurfacePtr create_offscreen_surface(int32_t w, int32_t h, bool alpha = false);
+	PictureID create_picture(int32_t w, int32_t h, bool alpha = false);
 
 	PictureID create_grayed_out_pic(const PictureID & picid);
-	RenderTarget * get_surface_renderer(const PictureID & pic);
 
 	enum  ResizeMode {
 		// do not worry about proportions, just sketch to requested size
@@ -163,7 +170,6 @@
 
 	PictureID get_resized_picture
 		(PictureID, uint32_t w, uint32_t h, ResizeMode);
-	SDL_Surface * resize(const PictureID index, uint32_t w, uint32_t h);
 
 	uint32_t get_maptexture(char const & fnametempl, uint32_t frametime);
 	void animate_maptextures(uint32_t time);
@@ -183,10 +189,13 @@
 	Texture * get_maptexture_data(uint32_t id);
 	AnimationGfx * get_animation(uint32_t) const;
 
-	Surface * get_road_texture(int32_t roadtex);
+	PictureID get_road_texture(int32_t roadtex);
 
 	GraphicCaps const & caps() const throw () {return m_caps;}
 
+private:
+	SDL_Surface * extract_sdl_surface(IPixelAccess & pix, Rect srcrect);
+
 protected:
 	// Static helper function for png writing
 	static void m_png_write_function
@@ -197,7 +206,7 @@
 
 	/// This is the main screen Surface.
 	/// A RenderTarget for this can be retrieved with get_render_target()
-	Surface * m_screen;
+	SurfacePtr m_screen;
 	/// This saves a copy of the screen SDL_Surface. This is needed for
 	/// opengl rendering as the SurfaceOpenGL does not use it. It allows
 	/// manipulation the screen context.
@@ -214,12 +223,19 @@
 	/// stores which features the current renderer has
 	GraphicCaps m_caps;
 
-	/// hash of filename/picture ID pairs
-	std::vector
-		<std::map<std::string, boost::shared_ptr<Picture> > > m_picturemap;
-	typedef std::map<std::string, boost::shared_ptr<Picture> > Picturemap;
+	struct PictureRec {
+		PictureID picture;
+
+		/// bit-mask of modules that this picture exists in
+		uint32_t modules;
+	};
+
+	typedef std::map<std::string, PictureRec> Picturemap;
 	typedef Picturemap::iterator pmit;
 
+	/// hash of cached filename/picture pairs
+	Picturemap m_picturemap;
+
 	Road_Textures * m_roadtextures;
 	std::vector<Texture *> m_maptextures;
 	std::vector<AnimationGfx *> m_animations;
@@ -229,4 +245,3 @@
 extern bool g_opengl;
 
 #endif
-

=== added file 'src/graphic/offscreensurface.h'
--- src/graphic/offscreensurface.h	1970-01-01 00:00:00 +0000
+++ src/graphic/offscreensurface.h	2010-11-29 19:01:16 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef OFFSCREENSURFACE_H
+#define OFFSCREENSURFACE_H
+
+#include "picture.h"
+#include "pixelaccess.h"
+#include "surface.h"
+
+/**
+ * Interface to surfaces that can act conveniently both as
+ * source and as destination for rendering.
+ */
+struct IOffscreenSurface : Surface, IPicture, IPixelAccess {
+};
+
+#endif // OFFSCREENSURFACE_H

=== modified file 'src/graphic/picture.cc'
--- src/graphic/picture.cc	2009-07-17 18:12:17 +0000
+++ src/graphic/picture.cc	2010-11-29 19:01:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009 by the Widelands Development Team
+ * Copyright (C) 2009-2010 by the Widelands Development Team
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -19,12 +19,25 @@
 
 #include "picture.h"
 
-#include "surface.h"
-#include "rendertarget.h"
-
-Picture::~Picture() {
-	delete surface;
-	free(fname);
-	delete rendertarget;
+#include "wexception.h"
+
+struct NullPicture : IPicture {
+	virtual bool valid() {return false;}
+
+	virtual uint32_t get_w() {return 0;}
+	virtual uint32_t get_h() {return 0;}
+
+	virtual IPixelAccess & pixelaccess() {throw wexception("pixelaccess() attempted on null picture");}
+	virtual Surface & surface() {throw wexception("surface() attempted on null picture");}
+};
+
+/**
+ * \return an invalid, null picture
+ *
+ * \see Graphic::get_no_picture
+ */
+const PictureID & IPicture::null()
+{
+	static PictureID thenull(new NullPicture);
+	return thenull;
 }
-

=== modified file 'src/graphic/picture.h'
--- src/graphic/picture.h	2010-11-10 20:05:21 +0000
+++ src/graphic/picture.h	2010-11-29 19:01:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002-2004, 2006-2009 by the Widelands Development Team
+ * Copyright (C) 2002-2004, 2006-2010 by the Widelands Development Team
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -20,43 +20,36 @@
 #ifndef PICTURE_H
 #define PICTURE_H
 
-/***
- * Picture/PictureID
- *
- * PictureID is a reference to a picture
- * picmod is used to specify which buffer picture is loaded in.
- * warning: a picture can be loaded multiple times in multiple buffers
- * when buffer is flushed pictures will hang around till the last reference
- * is gone too
- ***/
-
-
-struct RenderTarget;
+#include <stdint.h>
+#include <string>
+
+#include "picture_id.h"
+
+struct IPixelAccess;
 struct Surface;
 
-/// picture module flags
-enum PicMod {
-	INVALID     = 0,
-	PicMod_UI   = 1,
-	PicMod_Menu = 2,
-	PicMod_Game = 3,
-	PicMod_Font = 4,
-	PicSurface  = 5,
-	MaxModule   = 6 //MaxModule ALWAYS has to be the 'size' of picmod
-};
-
-struct Picture {
-	Picture() : module(INVALID), surface(0), fname(0), rendertarget(0) {}
-	~Picture();
-	//void operator delete(void * p);
-
-	//PicMod lists which 'buffer' to load the images in.
-	// INVALID if unused, MaxModule not a legal module
-	PicMod    module;
-	Surface * surface;
-
-	char         * fname; //  module & (PicMod_UI|PicMod_Menu|PicMod_Game)
-	RenderTarget * rendertarget; //  module & (PicMod_Font | PicSurface)
+/**
+ * Interface to a bitmap that can act as the source of a rendering
+ * operation.
+ */
+struct IPicture {
+	IPicture() {}
+	virtual ~IPicture() {}
+
+	virtual bool valid() = 0;
+
+	virtual uint32_t get_w() = 0;
+	virtual uint32_t get_h() = 0;
+
+	virtual IPixelAccess & pixelaccess() = 0;
+
+private:
+	// forbid copying
+	IPicture(const IPicture &);
+	IPicture & operator= (const IPicture &);
+
+public:
+	static const PictureID & null();
 };
 
 #endif

=== modified file 'src/graphic/picture_id.h'
--- src/graphic/picture_id.h	2009-11-22 14:46:22 +0000
+++ src/graphic/picture_id.h	2010-11-29 19:01:16 +0000
@@ -21,8 +21,8 @@
 
 #include <boost/shared_ptr.hpp>
 
-struct Picture;
+struct IPicture;
 
-typedef boost::shared_ptr<Picture> PictureID;
+typedef boost::shared_ptr<IPicture> PictureID;
 
 #endif

=== added file 'src/graphic/pixelaccess.h'
--- src/graphic/pixelaccess.h	1970-01-01 00:00:00 +0000
+++ src/graphic/pixelaccess.h	2010-11-29 19:01:16 +0000
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef PIXELACCESS_H
+#define PIXELACCESS_H
+
+#include <stdint.h>
+
+struct SDL_PixelFormat;
+
+/**
+ * Interface that provides direct pixel access to a picture or surface.
+ *
+ * \note Direct pixel access should be used only carefully, since it can be
+ * extremely slow.
+ */
+struct IPixelAccess {
+	enum LockMode {
+		/**
+		 * Normal mode preserves pre-existing pixel data so that it can
+		 * be read or modified.
+		 */
+		Lock_Normal = 0,
+
+		/**
+		 * Discard mode discards pre-existing pixel data. All pixels
+		 * will be undefined unless they are re-written.
+		 */
+		Lock_Discard
+	};
+
+	enum UnlockMode {
+		/**
+		 * Update mode will ensure that any changes in the pixel data
+		 * will appear in subsequent operations.
+		 */
+		Unlock_Update = 0,
+
+		/**
+		 * NoChange mode indicates that the caller changed no pixel data.
+		 *
+		 * \note If the caller did change pixel data but specifies NoChange
+		 * mode, the results are undefined.
+		 */
+		Unlock_NoChange
+	};
+
+	IPixelAccess() {}
+	virtual ~IPixelAccess() {}
+
+	/// Get width and height
+	//@{
+	virtual uint32_t get_w() = 0;
+	virtual uint32_t get_h() = 0;
+	//@}
+
+	/// This returns the pixel format for direct pixel access.
+	virtual SDL_PixelFormat const & format() const = 0;
+
+	/**
+	 * Lock/Unlock pairs must guard any of the direct pixel access using the
+	 * functions below.
+	 *
+	 * \note Lock/Unlock pairs cannot be nested.
+	 */
+	//@{
+	virtual void lock(LockMode) = 0;
+	virtual void unlock(UnlockMode) = 0;
+	//@}
+
+	//@{
+	virtual uint32_t get_pixel(uint32_t x, uint32_t y) = 0;
+	virtual void set_pixel(uint32_t x, uint32_t y, uint32_t clr) = 0;
+	//@}
+
+	/**
+	 * \return Pitch of the raw pixel data, i.e. the number of bytes
+	 * contained in each image row. This can be strictly larger than
+	 * bytes per pixel times the width.
+	 */
+	virtual uint16_t get_pitch() const = 0;
+
+	/**
+	 * \return Pointer to the raw pixel data.
+	 *
+	 * \warning May only be called inside lock/unlock pairs.
+	 */
+	virtual uint8_t * get_pixels() const = 0;
+
+private:
+	IPixelAccess & operator= (const IPixelAccess &);
+};
+
+#endif // PIXELSURFACE_H

=== modified file 'src/graphic/render/animationgfx.cc'
--- src/graphic/render/animationgfx.cc	2010-05-18 19:34:36 +0000
+++ src/graphic/render/animationgfx.cc	2010-11-29 19:01:16 +0000
@@ -22,8 +22,8 @@
 #include "io/streamwrite.h"
 
 #include "surface_sdl.h"
-#include "surface_opengl.h"
 #include "graphic/graphic.h"
+#include "graphic/picture.h"
 
 #include "log.h"
 #include "upcast.h"
@@ -99,17 +99,17 @@
 			strcpy(after_basename, extensions[extnr]);
 			if (g_fs->FileExists(filename)) { //  Is the frame actually there?
 				try {
-					Surface & surface = g_gr->load_image(filename, true);
+					PictureID pic = g_gr->load_image(filename, true);
 					if (width == 0) { //  This is the first frame.
-						width  = surface.get_w();
-						height = surface.get_h();
-					} else if (width != surface.get_w() or height != surface.get_h())
+						width  = pic->get_w();
+						height = pic->get_h();
+					} else if (width != pic->get_w() or height != pic->get_h())
 						throw wexception
 							("wrong size: (%u, %u), should be (%u, %u) like the "
 							 "first frame",
-							 surface.get_w(), surface.get_h(), width, height);
+							 pic->get_w(), pic->get_h(), width, height);
 					//  Get a new AnimFrame.
-					m_plrframes[0].push_back(&surface);
+					m_plrframes[0].push_back(pic);
 #ifdef VALIDATE_ANIMATION_CROPPING
 					if (not data_in_x_min)
 						for (int y = 0; y < height; ++y) {
@@ -179,13 +179,13 @@
 				strcpy(after_basename + 3, extensions[extnr]);
 				if (g_fs->FileExists(filename)) {
 					try {
-						Surface & surface = g_gr->load_image(filename, true);
-						if (width != surface.get_w() or height != surface.get_h())
+						PictureID picture = g_gr->load_image(filename, true);
+						if (width != picture->get_w() or height != picture->get_h())
 							throw wexception
 								("playercolor mask has wrong size: (%u, %u), should "
 								 "be (%u, %u) like the animation frame",
-								 surface.get_w(), surface.get_h(), width, height);
-						m_pcmasks.push_back(&surface);
+								 picture->get_w(), picture->get_h(), width, height);
+						m_pcmasks.push_back(picture);
 						break;
 					} catch (std::exception const & e) {
 						throw wexception
@@ -243,14 +243,6 @@
 
 AnimationGfx::~AnimationGfx()
 {
-	for (Widelands::Player_Number i = 0; i <= MAX_PLAYERS; ++i) {
-		std::vector<Surface *> & frames = m_plrframes[i];
-		for (uint32_t j = 0; j < frames.size(); ++j)
-			delete frames[j];
-	}
-
-	for (uint32_t j = 0; j < m_pcmasks.size(); ++j)
-		delete m_pcmasks[j];
 }
 
 
@@ -262,47 +254,36 @@
 void AnimationGfx::encode(uint8_t const plr, RGBColor const * const plrclrs)
 {
 	assert(m_plrframes[0].size() == m_pcmasks.size());
-	std::vector<Surface *> & frames = m_plrframes[plr];
+	std::vector<PictureID> & frames = m_plrframes[plr];
 
 	for (uint32_t i = 0; i < m_plrframes[0].size(); ++i) {
 		//  Copy the old surface.
-		Surface & origsurface = *m_plrframes[0][i];
-		Surface & newsurface = g_gr->create_surface(origsurface, true);
-
-		Surface & pcmask = *m_pcmasks[i];
-		SDL_PixelFormat * fmt, * fmt_pc;
-
-#ifdef USE_OPENGL
-		upcast(SurfaceOpenGL, oglsurf, &origsurface);
-
-		if (oglsurf)
-		{
-			fmt_pc = fmt = new SDL_PixelFormat;
-			memset(fmt, 0, sizeof(SDL_PixelFormat));
-			fmt->BitsPerPixel = 32; fmt->BytesPerPixel = 4;
-			fmt->Amask = 0xFF000000; fmt->Ashift = 24;
-			fmt->Bmask = 0x00FF0000; fmt->Bshift = 16;
-			fmt->Gmask = 0x0000FF00; fmt->Gshift = 8;
-			fmt->Rmask = 0x000000FF; fmt->Rshift = 0;
-		} else
-#endif
-		{
-			fmt = const_cast<SDL_PixelFormat *>(&newsurface.format());
-			fmt_pc = const_cast<SDL_PixelFormat *>(&pcmask.format());
-		}
-
-		origsurface.lock();
-		pcmask.lock();
-		newsurface.lock();
+		PictureID origpic = m_plrframes[0][i];
+		uint32_t w = origpic->get_w();
+		uint32_t h = origpic->get_h();
+		IPixelAccess & origpix = m_plrframes[0][i]->pixelaccess();
+		IPixelAccess & pcmask = m_pcmasks[i]->pixelaccess();
+
+		PictureID newpicture = g_gr->create_picture(w, h, true);
+		IPixelAccess & newpix = newpicture->pixelaccess();
+
+		const SDL_PixelFormat & fmt = origpix.format();
+		const SDL_PixelFormat & fmt_pc = pcmask.format();
+		const SDL_PixelFormat & destfmt = newpix.format();
+
+		origpix.lock(IPixelAccess::Lock_Normal);
+		pcmask.lock(IPixelAccess::Lock_Normal);
+		newpix.lock(IPixelAccess::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 < newsurface.get_h(); ++y) {
-			for (uint32_t x = 0; x < newsurface.get_w(); ++x) {
+		for (uint32_t y = 0; y < h; ++y) {
+			for (uint32_t x = 0; x < w; ++x) {
 				RGBAColor source;
 				RGBAColor mask;
+				RGBAColor product;
 
-				source.set(*fmt, newsurface.get_pixel(x, y));
-				mask.set(*fmt_pc, pcmask.get_pixel(x, y));
+				source.set(fmt, origpix.get_pixel(x, y));
+				mask.set(fmt_pc, pcmask.get_pixel(x, y));
 
 				if
 					(uint32_t const influence =
@@ -320,23 +301,25 @@
 					plrclr.g = (plrclrs[3].g() * intensity) >> 8;
 					plrclr.b = (plrclrs[3].b() * intensity) >> 8;
 
-					RGBAColor dest(source);
-					dest.r =
-						(plrclr.r * influence + dest.r * (65536 - influence)) >> 16;
-					dest.g =
-						(plrclr.g * influence + dest.g * (65536 - influence)) >> 16;
-					dest.b =
-						(plrclr.b * influence + dest.b * (65536 - influence)) >> 16;
-
-					newsurface.set_pixel(x, y, dest.map(*fmt));
+					product.r =
+						(plrclr.r * influence + source.r * (65536 - influence)) >> 16;
+					product.g =
+						(plrclr.g * influence + source.g * (65536 - influence)) >> 16;
+					product.b =
+						(plrclr.b * influence + source.b * (65536 - influence)) >> 16;
+					product.a = source.a;
+				} else {
+					product = source;
 				}
+
+				newpix.set_pixel(x, y, product.map(destfmt));
 			}
 		}
-		origsurface.unlock();
-		pcmask.unlock();
-		newsurface.unlock();
+		origpix.unlock(IPixelAccess::Unlock_NoChange);
+		pcmask.unlock(IPixelAccess::Unlock_NoChange);
+		newpix.unlock(IPixelAccess::Unlock_Update);
 
-		frames.push_back(&newsurface);
+		frames.push_back(newpicture);
 	}
 }
 

=== modified file 'src/graphic/render/gameview.cc'
--- src/graphic/render/gameview.cc	2010-11-02 00:07:12 +0000
+++ src/graphic/render/gameview.cc	2010-11-29 19:01:16 +0000
@@ -33,7 +33,6 @@
 #include "graphic/graphic.h"
 #include "graphic/rendertarget.h"
 #include "graphic/surface.h"
-#include "surface_opengl.h"
 #include "surface_sdl.h"
 #include "graphic/texture.h"
 
@@ -973,13 +972,10 @@
 	 Texture const &  f_d_texture,
 	 Texture const &  f_r_texture)
 {
-	upcast(SurfaceSDL, sdlsurf, m_surface);
-#ifdef USE_OPENGL
-	upcast(SurfaceOpenGL, oglsurf, m_surface);
-#endif
+	upcast(SurfaceSDL, sdlsurf, m_surface.get());
 	if (sdlsurf)
 	{
-		dynamic_cast<SurfaceSDL *>(m_surface)->set_subwin(subwin);
+		sdlsurf->set_subwin(subwin);
 		switch (sdlsurf->format().BytesPerPixel) {
 		case 2:
 			draw_field_int<Uint16>
@@ -998,16 +994,17 @@
 		default:
 			assert(false);
 		}
-		dynamic_cast<SurfaceSDL *>(m_surface)->unset_subwin();
+		sdlsurf->unset_subwin();
 	}
 #ifdef USE_OPENGL
-	else if (oglsurf) {
+	else
+	{
 		// Draw triangle right (bottom) of the field
 		draw_field_opengl
-			(*oglsurf, subwin, f_vert, br_vert, r_vert, f_r_texture);
+			(subwin, f_vert, br_vert, r_vert, f_r_texture);
 		// Draw triangle bottom of the field
 		draw_field_opengl
-			(*oglsurf, subwin, f_vert, bl_vert, br_vert, f_d_texture);
+			(subwin, f_vert, bl_vert, br_vert, f_d_texture);
 		// Draw the roads
 		draw_roads_opengl(subwin, roads, f_vert, r_vert, bl_vert, br_vert);
 	}
@@ -1273,7 +1270,7 @@
 	//       necesary. The created surface could be cached and only redrawn two
 	//       or three times per second
 	const SDL_PixelFormat & fmt =
-		g_gr->get_render_target()->get_surface().format();
+		g_gr->get_render_target()->get_surface()->pixelaccess().format();
 	SDL_Surface * surface =
 		SDL_CreateRGBSurface
 			(SDL_SWSURFACE,
@@ -1312,11 +1309,9 @@
 
 	SDL_UnlockSurface(surface);
 
-	Surface & surf = g_gr->create_surface(*surface);
-
-	m_surface->blit(Point(rc.x, rc.y), &surf, rc2, false);
-
-	delete &surf;
+	PictureID picture = g_gr->convert_sdl_surface_to_picture(surface);
+
+	m_surface->blit(Point(rc.x, rc.y), picture, rc2);
 }
 
 void GameView::rendermap_init()

=== added file 'src/graphic/render/gl_picture_texture.cc'
--- src/graphic/render/gl_picture_texture.cc	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gl_picture_texture.cc	2010-11-29 19:01:16 +0000
@@ -0,0 +1,235 @@
+/*
+ * Copyright 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "gl_picture_texture.h"
+
+#include <SDL_video.h>
+
+#include "gl_utils.h"
+#include "graphic/graphic.h"
+#include "wexception.h"
+
+
+/**
+ * Initialize an OpenGL texture of the given dimensions.
+ *
+ * The initial data of the texture is undefined.
+ */
+GLPictureTexture::GLPictureTexture(int w, int h)
+{
+	init(w, h);
+}
+
+/**
+ * Initialize an OpenGL texture with the contents of the given surface.
+ *
+ * \note Takes ownership of the given surface.
+ */
+GLPictureTexture::GLPictureTexture(SDL_Surface * surface)
+{
+	init(surface->w, surface->h);
+
+	// Convert image data
+	uint8_t bpp = surface->format->BytesPerPixel;
+
+	if
+		(surface->format->palette or (surface->format->colorkey > 0) or
+		 m_tex_w != static_cast<uint32_t>(surface->w) or
+		 m_tex_h != static_cast<uint32_t>(surface->h) or
+		 (bpp != 3 && bpp != 4))
+	{
+		SDL_Surface * converted = SDL_CreateRGBSurface
+			(SDL_SWSURFACE, m_tex_w, m_tex_h,
+			 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
+		assert(converted);
+		SDL_SetAlpha(converted, 0, 0);
+		SDL_SetAlpha(surface, 0, 0);
+		SDL_BlitSurface(surface, 0, converted, 0);
+		SDL_FreeSurface(surface);
+		surface = converted;
+		bpp = surface->format->BytesPerPixel;
+	}
+
+	SDL_PixelFormat const & fmt = *surface->format;
+	GLenum pixels_format;
+
+	glPushAttrib(GL_PIXEL_MODE_BIT);
+
+	if (bpp == 4) {
+		if
+			(fmt.Rmask == 0x000000ff and fmt.Gmask == 0x0000ff00 and
+			 fmt.Bmask == 0x00ff0000)
+		{
+			if (fmt.Amask == 0xff000000) {
+				pixels_format = GL_RGBA;
+			} else {
+				pixels_format = GL_RGBA;
+				// Read four bytes per pixel but ignore the alpha value
+				glPixelTransferi(GL_ALPHA_SCALE, 0.0f);
+				glPixelTransferi(GL_ALPHA_BIAS, 1.0f);
+			}
+		} else if
+			(fmt.Bmask == 0x000000ff and fmt.Gmask == 0x0000ff00 and
+			 fmt.Rmask == 0x00ff0000)
+		{
+			if (fmt.Amask == 0xff000000) {
+				pixels_format = GL_BGRA;
+			} else {
+				pixels_format = GL_BGRA;
+				// Read four bytes per pixel but ignore the alpha value
+				glPixelTransferi(GL_ALPHA_SCALE, 0.0f);
+				glPixelTransferi(GL_ALPHA_BIAS, 1.0f);
+			}
+		} else
+			throw wexception("OpenGL: Unknown pixel format");
+	} else  if (bpp == 3) {
+		if
+			(fmt.Rmask == 0x000000ff and fmt.Gmask == 0x0000ff00 and
+			 fmt.Bmask == 0x00ff0000)
+		{
+			pixels_format = GL_RGB;
+		} else if
+			(fmt.Bmask == 0x000000ff and fmt.Gmask == 0x0000ff00 and
+			 fmt.Rmask == 0x00ff0000)
+		{
+			pixels_format = GL_BGR;
+		} else
+			throw wexception("OpenGL: Unknown pixel format");
+	} else
+		throw wexception("OpenGL: Unknown pixel format");
+
+	SDL_LockSurface(surface);
+
+	glTexImage2D
+		(GL_TEXTURE_2D, 0, GL_RGBA, m_tex_w, m_tex_h, 0,
+		 pixels_format, GL_UNSIGNED_BYTE, surface->pixels);
+
+	SDL_UnlockSurface(surface);
+	SDL_FreeSurface(surface);
+
+	glPopAttrib();
+	handle_glerror();
+}
+
+GLPictureTexture::~GLPictureTexture()
+{
+	glDeleteTextures(1, &m_texture);
+}
+
+void GLPictureTexture::init(uint32_t w, uint32_t h)
+{
+	handle_glerror();
+
+	m_w = w;
+	m_h = h;
+
+	if (g_gr->caps().gl.tex_power_of_two) {
+		m_tex_w = next_power_of_two(w);
+		m_tex_h = next_power_of_two(h);
+	} else {
+		m_tex_w = w;
+		m_tex_h = h;
+	}
+
+	glGenTextures(1, &m_texture);
+	glBindTexture(GL_TEXTURE_2D, m_texture);
+
+	// set texture filter to use linear filtering. This looks nicer for resized
+	// texture. Most textures and images are not resized so the filtering
+	// makes no difference
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+	handle_glerror();
+}
+
+bool GLPictureTexture::valid()
+{
+	return true;
+}
+
+uint32_t GLPictureTexture::get_w()
+{
+	return m_w;
+}
+
+uint32_t GLPictureTexture::get_h()
+{
+	return m_h;
+}
+
+const SDL_PixelFormat & GLPictureTexture::format() const
+{
+	return gl_rgba_format();
+}
+
+void GLPictureTexture::lock(LockMode mode)
+{
+	assert(!m_pixels);
+
+	m_pixels.reset(new uint8_t[m_tex_w * m_tex_h * 4]);
+
+	if (mode == Lock_Normal) {
+		glBindTexture(GL_TEXTURE_2D, m_texture);
+		glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_pixels.get());
+	}
+}
+
+void GLPictureTexture::unlock(UnlockMode mode)
+{
+	assert(m_pixels);
+
+	if (mode == Unlock_Update) {
+		glBindTexture(GL_TEXTURE_2D, m_texture);
+		glTexImage2D
+			(GL_TEXTURE_2D, 0, GL_RGBA, m_tex_w, m_tex_h, 0, GL_RGBA,
+			 GL_UNSIGNED_BYTE,  m_pixels.get());
+	}
+
+	m_pixels.reset(0);
+}
+
+uint16_t GLPictureTexture::get_pitch() const
+{
+	return 4 * m_tex_w;
+}
+
+uint8_t * GLPictureTexture::get_pixels() const
+{
+	return m_pixels.get();
+}
+
+uint32_t GLPictureTexture::get_pixel(uint32_t x, uint32_t y)
+{
+	assert(m_pixels);
+	assert(x < m_w);
+	assert(y < m_h);
+
+	uint8_t * data = &m_pixels[(y * m_tex_w + x) * 4];
+	return *(reinterpret_cast<uint32_t *>(data));
+}
+
+void GLPictureTexture::set_pixel(uint32_t x, uint32_t y, uint32_t clr)
+{
+	assert(m_pixels);
+	assert(x < m_w);
+	assert(y < m_h);
+
+	uint8_t * data = &m_pixels[(y * m_tex_w + x) * 4];
+	*(reinterpret_cast<uint32_t *>(data)) = clr;
+}

=== added file 'src/graphic/render/gl_picture_texture.h'
--- src/graphic/render/gl_picture_texture.h	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gl_picture_texture.h	2010-11-29 19:01:16 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef GL_PICTURE_TEXTURE_H
+#define GL_PICTURE_TEXTURE_H
+
+#include <boost/scoped_array.hpp>
+
+#include <SDL_opengl.h>
+
+#include "graphic/picture.h"
+#include "graphic/pixelaccess.h"
+
+struct SDL_Surface;
+
+struct GLPictureTexture : IPicture, IPixelAccess {
+	GLPictureTexture(SDL_Surface * surface);
+	GLPictureTexture(int w, int h);
+	~GLPictureTexture();
+
+	/// Interface implementation
+	//@{
+	virtual bool valid();
+
+	virtual uint32_t get_w();
+	virtual uint32_t get_h();
+
+	virtual const SDL_PixelFormat & format() const;
+	virtual void lock(LockMode);
+	virtual void unlock(UnlockMode);
+	virtual uint16_t get_pitch() const;
+	virtual uint8_t * get_pixels() const;
+	virtual void set_pixel(uint32_t x, uint32_t y, uint32_t clr);
+	virtual uint32_t get_pixel(uint32_t x, uint32_t y);
+
+	virtual IPixelAccess & pixelaccess() {return *this;}
+	//@}
+
+	GLuint get_gl_texture() const {return m_texture;}
+	uint32_t get_tex_w() const {return m_tex_w;}
+	uint32_t get_tex_h() const {return m_tex_h;}
+
+private:
+	void init(uint32_t w, uint32_t h);
+
+private:
+	GLuint m_texture;
+
+	/// Logical width and height of the surface
+	uint32_t m_w, m_h;
+
+	/// Keep the size of the opengl texture. This is necessary because some
+	/// systems support only a power of two for texture sizes.
+	uint32_t m_tex_w, m_tex_h;
+
+	/// Pixel data, while the texture is locked
+	boost::scoped_array<uint8_t> m_pixels;
+};
+
+#endif //GL_PICTURE_TEXTURE_H

=== added file 'src/graphic/render/gl_surface_screen.cc'
--- src/graphic/render/gl_surface_screen.cc	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gl_surface_screen.cc	2010-11-29 19:01:16 +0000
@@ -0,0 +1,286 @@
+/*
+ * Copyright 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "gl_surface_screen.h"
+
+#include "gl_picture_texture.h"
+#include "gl_utils.h"
+#include "graphic/graphic.h"
+#include "upcast.h"
+
+GLSurfaceScreen::GLSurfaceScreen(uint32_t w, uint32_t h)
+{
+	m_w = w;
+	m_h = h;
+}
+
+bool GLSurfaceScreen::valid()
+{
+	return true;
+}
+
+uint32_t GLSurfaceScreen::get_w()
+{
+	return m_w;
+}
+
+uint32_t GLSurfaceScreen::get_h()
+{
+	return m_h;
+}
+
+void GLSurfaceScreen::update()
+{
+	assert(g_opengl);
+	SDL_GL_SwapBuffers();
+}
+
+const SDL_PixelFormat & GLSurfaceScreen::format() const
+{
+	return gl_rgba_format();
+}
+
+void GLSurfaceScreen::lock(IPixelAccess::LockMode mode)
+{
+	assert(!m_pixels);
+
+	m_pixels.reset(new uint8_t[m_w * m_h * 4]);
+
+	if (mode == Lock_Normal)
+		glReadPixels(0, 0, m_w, m_h, GL_RGBA, GL_UNSIGNED_BYTE, m_pixels.get());
+}
+
+void GLSurfaceScreen::unlock(IPixelAccess::UnlockMode mode)
+{
+	assert(m_pixels);
+
+	if (mode == Unlock_Update)
+		glDrawPixels(m_w, m_h, GL_RGBA, GL_UNSIGNED_BYTE, m_pixels.get());
+
+	m_pixels.reset(0);
+}
+
+uint16_t GLSurfaceScreen::get_pitch() const
+{
+	return 4 * m_w;
+}
+
+uint8_t * GLSurfaceScreen::get_pixels() const
+{
+	return m_pixels.get();
+}
+
+uint32_t GLSurfaceScreen::get_pixel(uint32_t x, uint32_t y)
+{
+	assert(m_pixels);
+	assert(x < m_w);
+	assert(y < m_h);
+
+	uint8_t * data = &m_pixels[4 * (y * m_w + x)];
+	return *(reinterpret_cast<uint32_t *>(data));
+}
+
+void GLSurfaceScreen::set_pixel(uint32_t x, uint32_t y, Uint32 clr)
+{
+	assert(m_pixels);
+	assert(x < m_w);
+	assert(y < m_h);
+
+	uint8_t * data = &m_pixels[4 * (y * m_w + x)];
+	*(reinterpret_cast<uint32_t *>(data)) = clr;
+}
+
+/**
+ * Draws the outline of a rectangle
+ */
+void GLSurfaceScreen::draw_rect(const Rect rc, const RGBColor clr)
+{
+	assert(g_opengl);
+	glDisable(GL_BLEND);
+	glDisable(GL_TEXTURE_2D);
+
+	glBegin(GL_LINE_LOOP); {
+		glColor3ub(clr.r(), clr.g(), clr.b());
+		glVertex2f(rc.x + 0.5f,        rc.y + 0.5f);
+		glVertex2f(rc.x + rc.w - 0.5f, rc.y + 0.5f);
+		glVertex2f(rc.x + rc.w - 0.5f, rc.y + rc.h - 0.5f);
+		glVertex2f(rc.x + 0.5f,        rc.y + rc.h - 0.5f);
+	} glEnd();
+	glEnable(GL_TEXTURE_2D);
+}
+
+
+/**
+ * Draws a filled rectangle
+ */
+void GLSurfaceScreen::fill_rect(const Rect rc, const RGBAColor clr) {
+	assert(rc.x >= 0);
+	assert(rc.y >= 0);
+	assert(rc.w >= 0);
+	assert(rc.h >= 0);
+	assert(g_opengl);
+
+	glDisable(GL_TEXTURE_2D);
+	glDisable(GL_BLEND);
+
+	glBegin(GL_QUADS); {
+		glColor4ub(clr.r, clr.g, clr.b, clr.a);
+		glVertex2f(rc.x,        rc.y);
+		glVertex2f(rc.x + rc.w, rc.y);
+		glVertex2f(rc.x + rc.w, rc.y + rc.h);
+		glVertex2f(rc.x,        rc.y + rc.h);
+	} glEnd();
+	glEnable(GL_TEXTURE_2D);
+}
+
+/**
+ * Change the brightness of the given rectangle
+ */
+void GLSurfaceScreen::brighten_rect(const Rect rc, const int32_t factor)
+{
+	if (!factor)
+		return;
+
+	assert(rc.x >= 0);
+	assert(rc.y >= 0);
+	assert(rc.w >= 1);
+	assert(rc.h >= 1);
+	assert(g_opengl);
+
+	/* glBlendFunc is a very nice feature of opengl. You can specify how the
+	* color is calculated.
+	*
+	* glBlendFunc(GL_ONE, GL_ONE) means the following:
+	* Rnew = Rdest + Rsrc
+	* Gnew = Gdest + Gsrc
+	* Bnew = Bdest + Bsrc
+	* Anew = Adest + Asrc
+	* where Xnew is the new calculated color for destination, Xdest is the old
+	* color of the destination and Xsrc is the color of the source.
+	*/
+	glEnable(GL_BLEND);
+	glDisable(GL_TEXTURE_2D);
+	glBlendFunc(GL_ONE, GL_ONE);
+
+	// And now simply draw a rect with facor as the color
+	// (this is the source color) over the region
+	glBegin(GL_QUADS); {
+		glColor3f
+			((static_cast<GLfloat>(factor) / 256.0f),
+			 (static_cast<GLfloat>(factor) / 256.0f),
+			 (static_cast<GLfloat>(factor) / 256.0f));
+		glVertex2f(rc.x,        rc.y);
+		glVertex2f(rc.x + rc.w, rc.y);
+		glVertex2f(rc.x + rc.w, rc.y + rc.h);
+		glVertex2f(rc.x,        rc.y + rc.h);
+	} glEnd();
+}
+
+void GLSurfaceScreen::draw_line
+		(int32_t x1,
+		 int32_t y1,
+		 int32_t x2,
+		 int32_t y2,
+		 RGBColor color,
+		 const Rect * clip)
+{
+	if (clip) {
+		glPushAttrib(GL_ENABLE_BIT | GL_SCISSOR_BIT);
+		glScissor
+			(clip->x, g_gr->get_yres() - clip->y - clip->h, clip->w, clip->h);
+		glEnable(GL_SCISSOR_TEST);
+	}
+	glDisable(GL_BLEND);
+	glDisable(GL_TEXTURE_2D);
+	glBegin(GL_LINES); {
+		glColor3ub(color.r(), color.g(), color.b());
+		glVertex2f(x1 + 0.5f, y1 + 0.5f);
+		glVertex2f(x2 + 0.5f, y2 + 0.5f);
+	} glEnd();
+	if (clip) {
+		glPopAttrib();
+	}
+}
+
+/**
+ * Clear the entire screen to black
+ */
+void GLSurfaceScreen::clear()
+{
+	assert(g_opengl);
+	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+	glClear(GL_COLOR_BUFFER_BIT);
+}
+
+
+void GLSurfaceScreen::blit
+	(Point const dst, PictureID const src, Rect const srcrc, Composite cm)
+{
+	upcast(GLPictureTexture, oglsrc, src.get());
+	assert(oglsrc);
+	assert(g_opengl);
+
+	/* Set a texture scaling factor. Normaly texture coordiantes
+	* (see glBegin()...glEnd() Block below) are given in the range 0-1
+	* to avoid the calculation (and let opengl do it) the texture
+	* space is modified. glMatrixMode select which matrix to manipulate
+	* (the texture transformation matrix in this case). glLoadIdentity()
+	* resets the (selected) matrix to the identity matrix. And finally
+	* glScalef() calculates the texture matrix.
+	*/
+	glMatrixMode(GL_TEXTURE);
+	glLoadIdentity();
+	glScalef
+		(1.0f / static_cast<GLfloat>(oglsrc->get_tex_w()),
+		 1.0f / static_cast<GLfloat>(oglsrc->get_tex_h()), 1);
+
+	// Enable Alpha blending
+	if (cm == CM_Normal) {
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	} else {
+		glDisable(GL_BLEND);
+	}
+
+	glEnable(GL_TEXTURE_2D);
+	glBindTexture(GL_TEXTURE_2D, oglsrc->get_gl_texture());
+
+	glBegin(GL_QUADS); {
+		//  set color white, otherwise textures get mixed with color
+		glColor3f(1.0, 1.0, 1.0);
+		//  top-left
+		glTexCoord2i(srcrc.x,           srcrc.y);
+		glVertex2i  (dst.x,             dst.y);
+		//  top-right
+		glTexCoord2i(srcrc.x + srcrc.w, srcrc.y);
+		glVertex2f  (dst.x + srcrc.w,   dst.y);
+		//  bottom-right
+		glTexCoord2i(srcrc.x + srcrc.w, srcrc.y + srcrc.h);
+		glVertex2f  (dst.x + srcrc.w,   dst.y + srcrc.h);
+		//  bottom-left
+		glTexCoord2i(srcrc.x,           srcrc.y + srcrc.h);
+		glVertex2f  (dst.x,             dst.y + srcrc.h);
+	} glEnd();
+
+	glLoadIdentity();
+}
+
+void GLSurfaceScreen::fast_blit(PictureID src)
+{
+	blit(Point(0, 0), src, Rect(Point(0, 0), src->get_w(), src->get_h()), CM_Normal);
+}

=== added file 'src/graphic/render/gl_surface_screen.h'
--- src/graphic/render/gl_surface_screen.h	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gl_surface_screen.h	2010-11-29 19:01:16 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef GL_SURFACE_SCREEN_H
+#define GL_SURFACE_SCREEN_H
+
+#include <boost/scoped_array.hpp>
+
+#include "graphic/picture_id.h"
+#include "graphic/pixelaccess.h"
+#include "graphic/surface.h"
+
+/**
+ * This surface represents the screen in OpenGL mode.
+ */
+struct GLSurfaceScreen : Surface, IPixelAccess {
+	GLSurfaceScreen(uint32_t w, uint32_t h);
+
+	/// Interface implementations
+	//@{
+	virtual bool valid();
+
+	virtual uint32_t get_w();
+	virtual uint32_t get_h();
+
+	virtual void update();
+
+	virtual const SDL_PixelFormat & format() const;
+	virtual void lock(LockMode);
+	virtual void unlock(UnlockMode);
+	virtual uint16_t get_pitch() const;
+	virtual uint8_t * get_pixels() const;
+	virtual void set_pixel(uint32_t x, uint32_t y, Uint32 clr);
+	virtual uint32_t get_pixel(uint32_t x, uint32_t y);
+	virtual IPixelAccess & pixelaccess() {return *this;}
+
+	virtual void clear();
+	virtual void draw_rect(Rect, RGBColor);
+	virtual void fill_rect(Rect, RGBAColor);
+	virtual void brighten_rect(Rect, int32_t factor);
+
+	virtual void draw_line
+		(int32_t x1, int32_t y1,
+		 int32_t x2, int32_t y2,
+		 RGBColor, Rect const * clip = 0);
+
+	virtual void blit(Point, PictureID, Rect srcrc, Composite cm);
+	virtual void fast_blit(PictureID);
+	//@}
+
+private:
+	/// Size of the screen
+	uint32_t m_w, m_h;
+
+	/// Pixel data while locked
+	boost::scoped_array<uint8_t> m_pixels;
+};
+
+#endif // GL_SURFACE_SCREEN_H

=== added file 'src/graphic/render/gl_utils.cc'
--- src/graphic/render/gl_utils.cc	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gl_utils.cc	2010-11-29 19:01:16 +0000
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "gl_utils.h"
+
+#include <SDL_video.h>
+
+#include "log.h"
+
+/**
+ * Return the smallest power of two greater than or equal to \p x.
+ */
+uint32_t next_power_of_two(uint32_t x)
+{
+	uint32_t pot = 1;
+
+	while (pot < x)
+		pot *= 2;
+
+	return pot;
+}
+
+/**
+ * \return the standard 32-bit RGBA format that we use in OpenGL
+ */
+const SDL_PixelFormat & gl_rgba_format()
+{
+	static SDL_PixelFormat format;
+	static bool init = false;
+	if (init)
+		return format;
+
+	init = true;
+	memset(&format, 0, sizeof(format));
+	format.BitsPerPixel = 32;
+	format.BytesPerPixel = 4;
+	format.Rmask = 0x000000ff;
+	format.Gmask = 0x0000ff00;
+	format.Bmask = 0x00ff0000;
+	format.Amask = 0xff000000;
+	format.Rshift = 0;
+	format.Gshift = 8;
+	format.Bshift = 16;
+	format.Ashift = 24;
+	return format;
+}
+
+GLenum _handle_glerror(const char * file, unsigned int line)
+{
+	GLenum err = glGetError();
+#ifdef DEBUG
+	if (err == GL_NO_ERROR)
+		return err;
+
+	log("%s:%d: OpenGL ERROR: ", file, line);
+
+	switch (err)
+	{
+	case GL_INVALID_VALUE:
+		log("invalid value\n");
+		break;
+	case GL_INVALID_ENUM:
+		log("invalid enum\n");
+		break;
+	case GL_INVALID_OPERATION:
+		log("invalid operation\n");
+		break;
+	case GL_STACK_OVERFLOW:
+		log("stack overflow\n");
+		break;
+	case GL_STACK_UNDERFLOW:
+		log("stack undeflow\n");
+		break;
+	case GL_OUT_OF_MEMORY:
+		log("out of memory\n");
+		break;
+	case GL_TABLE_TOO_LARGE:
+		log("table too large\n");
+		break;
+	default:
+		log("unknown\n");
+	}
+#endif
+	return err;
+}

=== added file 'src/graphic/render/gl_utils.h'
--- src/graphic/render/gl_utils.h	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gl_utils.h	2010-11-29 19:01:16 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef GL_UTILS_H
+#define GL_UTILS_H
+
+#include <stdint.h>
+#include <SDL_opengl.h>
+
+struct SDL_PixelFormat;
+
+uint32_t next_power_of_two(uint32_t x);
+const SDL_PixelFormat & gl_rgba_format();
+GLenum _handle_glerror(const char * file, unsigned int line);
+
+/**
+ * handle_glerror() is intended to make debugging of oengl easier. It logs the
+ * error code returned by glGetError and returns the error code.
+ */
+#define handle_glerror() _handle_glerror(__FILE__, __LINE__)
+
+#endif // GL_UTILS_H

=== removed file 'src/graphic/render/render_opengl.cc'
--- src/graphic/render/render_opengl.cc	2010-11-01 22:37:46 +0000
+++ src/graphic/render/render_opengl.cc	1970-01-01 00:00:00 +0000
@@ -1,269 +0,0 @@
-/*
- * Copyright 2010 by the Widelands Development Team
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include "graphic/graphic.h"
-#include "surface_opengl.h"
-
-#include "log.h"
-#include "upcast.h"
-#include "wexception.h"
-
-#include <SDL.h>
-
-
-#ifdef USE_OPENGL
-
-/*
- * Updating the whole Surface
- */
-void SurfaceOpenGL::update() {
-	assert(g_opengl);
-	SDL_GL_SwapBuffers();
-}
-
-/*
-===============
-Draws the outline of a rectangle
-===============
-*/
-void SurfaceOpenGL::draw_rect(const Rect rc, const RGBColor clr) {
-	assert(g_opengl);
-	//log("SurfaceOpenGL::draw_rect() for opengl is experimental\n");
-	glDisable(GL_BLEND);
-	glDisable(GL_TEXTURE_2D);
-
-	glBegin(GL_LINE_LOOP); {
-		glColor3ub(clr.r(), clr.g(), clr.b());
-		glVertex2f(m_offsx + rc.x + 0.5f,        m_offsy + rc.y + 0.5f);
-		glVertex2f(m_offsx + rc.x + rc.w - 0.5f, m_offsy + rc.y + 0.5f);
-		glVertex2f(m_offsx + rc.x + rc.w - 0.5f, m_offsy + rc.y + rc.h - 0.5f);
-		glVertex2f(m_offsx + rc.x + 0.5f,        m_offsy + rc.y + rc.h - 0.5f);
-	} glEnd();
-	glEnable(GL_TEXTURE_2D);
-}
-
-
-/*
-===============
-Draws a filled rectangle
-===============
-*/
-void SurfaceOpenGL::fill_rect(const Rect rc, const RGBAColor clr) {
-	assert(rc.x >= 0);
-	assert(rc.y >= 0);
-	assert(rc.w >= 0);
-	assert(rc.h >= 0);
-	assert(g_opengl);
-
-	glDisable(GL_TEXTURE_2D);
-	glDisable(GL_BLEND);
-
-	glBegin(GL_QUADS); {
-		glColor4ub(clr.r, clr.g, clr.b, clr.a);
-		glVertex2f(m_offsx + rc.x,        m_offsy + rc.y);
-		glVertex2f(m_offsx + rc.x + rc.w, m_offsy + rc.y);
-		glVertex2f(m_offsx + rc.x + rc.w, m_offsy + rc.y + rc.h);
-		glVertex2f(m_offsx + rc.x,        m_offsy + rc.y + rc.h);
-	} glEnd();
-	glEnable(GL_TEXTURE_2D);
-}
-
-/*
-===============
-Change the brightness of the given rectangle
-This function is slow as hell.
-
-* This function is a possible point to optimize on
-  slow system. It takes a lot of cpu time atm and is
-  not needed. It is used by the ui_basic stuff to
-  highlight things.
-===============
-*/
-void SurfaceOpenGL::brighten_rect(const Rect rc, const int32_t factor) {
-	if (!factor)
-		return;
-
-	assert(rc.x >= 0);
-	assert(rc.y >= 0);
-	assert(rc.w >= 1);
-	assert(rc.h >= 1);
-	assert(g_opengl);
-
-	/* glBlendFunc is a very nice feature of opengl. You can specify how the
-	* color is calculated.
-	*
-	* glBlendFunc(GL_ONE, GL_ONE) means the following:
-	* Rnew = Rdest + Rsrc
-	* Gnew = Gdest + Gsrc
-	* Bnew = Bdest + Bsrc
-	* Anew = Adest + Asrc
-	* where Xnew is the new calculated color for destination, Xdest is the old
-	* color of the destination and Xsrc is the color of the source.
-	*/
-	glEnable(GL_BLEND);
-	glDisable(GL_TEXTURE_2D);
-	glBlendFunc(GL_ONE, GL_ONE);
-
-	// And now simply draw a rect with facor as the color
-	// (this is the source color) over the region
-	glBegin(GL_QUADS); {
-		glColor3f
-			((static_cast<GLfloat>(factor) / 256.0f),
-			 (static_cast<GLfloat>(factor) / 256.0f),
-			 (static_cast<GLfloat>(factor) / 256.0f));
-		glVertex2f(m_offsx + rc.x,        m_offsy + rc.y);
-		glVertex2f(m_offsx + rc.x + rc.w, m_offsy + rc.y);
-		glVertex2f(m_offsx + rc.x + rc.w, m_offsy + rc.y + rc.h);
-		glVertex2f(m_offsx + rc.x,        m_offsy + rc.y + rc.h);
-	} glEnd();
-}
-
-void SurfaceOpenGL::draw_line
-		(int32_t x1,
-		 int32_t y1,
-		 int32_t x2,
-		 int32_t y2,
-		 RGBColor color,
-		 const Rect * clip)
-{
-	if (clip) {
-		glPushAttrib(GL_ENABLE_BIT | GL_SCISSOR_BIT);
-		glScissor
-			(clip->x, g_gr->get_yres() - clip->y - clip->h, clip->w, clip->h);
-		glEnable(GL_SCISSOR_TEST);
-	}
-	glDisable(GL_BLEND);
-	glDisable(GL_TEXTURE_2D);
-	glBegin(GL_LINES); {
-		glColor3ub(color.r(), color.g(), color.b());
-		glVertex2f(x1 + m_offsx + 0.5f, y1 + m_offsy + 0.5f);
-		glVertex2f(x2 + m_offsx + 0.5f, y2 + m_offsy + 0.5f);
-	} glEnd();
-	if (clip) {
-		glPopAttrib();
-	}
-}
-
-/*
-===============
-Clear the entire bitmap to black
-===============
-*/
-void SurfaceOpenGL::clear()
-{
-	assert(g_opengl);
-	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-	glClear(GL_COLOR_BUFFER_BIT);
-	return;
-}
-
-
-void SurfaceOpenGL::blit
-	(Point const dst, Surface * const src, Rect const srcrc, bool enable_alpha)
-{
-	blit(Rect(dst, srcrc.w, srcrc.h), src, srcrc, enable_alpha);
-}
-
-
-void SurfaceOpenGL::blit
-	(Rect dst, Surface * src, Rect srcrc, bool enable_alpha)
-{
-	upcast(SurfaceOpenGL, oglsrc, src);
-
-	assert(g_opengl);
-#ifdef DEBUG
-	if (m_surf_type != SURFACE_SCREEN)
-	{
-		throw wexception
-			("Surface not the screen: Offscreen rendering not possible");
-		return;
-	}
-
-	if (not oglsrc)
-	{
-		throw wexception("Invalid surface: Not a opengl surface");
-	}
-#endif
-	GLuint tex;
-
-	try {
-		tex = oglsrc->get_texture();
-	} catch (...) {
-		throw wexception
-			("SurfaceOpenGL::blit(): Source surface has no texture\n");
-		return;
-	}
-
-	/* Set a texture scaling factor. Normaly texture coordiantes
-	* (see glBegin()...glEnd() Block below) are given in the range 0-1
-	* to avoid the calculation (and let opengl do it) the texture
-	* space is modified. glMatrixMode select which matrix to manipulate
-	* (the texture transformation matrix in this case). glLoadIdentity()
-	* resets the (selected) matrix to the identity matrix. And finally
-	* glScalef() calculates the texture matrix.
-	*/
-	glMatrixMode(GL_TEXTURE);
-	glLoadIdentity();
-	glScalef
-		(1.0f / static_cast<GLfloat>(oglsrc->get_tex_w()),
-		 1.0f / static_cast<GLfloat>(oglsrc->get_tex_h()), 1);
-
-	// Enable Alpha blending
-	if (enable_alpha) {
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	} else
-		glDisable(GL_BLEND);
-
-	/* select the texture to paint on the screen
-	* openGL does not know anything about SDL_Surfaces
-	* opengl uses textures to handle images
-	* getTexture() returns the texture id of the Surface. It creates
-	* the texture from the SDL_Surface if it doesn't exist
-	*/
-	glEnable(GL_TEXTURE_2D);
-	glBindTexture(GL_TEXTURE_2D, tex);
-
-	/* This block between blBegin() and glEnd() does the blit.
-	* It draws a textured rectangle. glTexCoord2i() set the Texture
-	* Texture cooardinates. This is the source rectangle.
-	* glVertex2f() sets the screen coordiantes which belong to the
-	* previous texture coordinate. This is the destination rectangle
-	*/
-
-	glBegin(GL_QUADS); {
-		//  set color white, otherwise textures get mixed with color
-		glColor3f(1.0, 1.0, 1.0);
-		//  top-left
-		glTexCoord2i(srcrc.x,           srcrc.y);
-		glVertex2i  (m_offsx + dst.x,   m_offsy + dst.y);
-		//  top-right
-		glTexCoord2i(srcrc.x + srcrc.w, srcrc.y);
-		glVertex2f  (m_offsx + dst.x + dst.w,  m_offsy + dst.y);
-		//  bottom-right
-		glTexCoord2i(srcrc.x + srcrc.w, srcrc.y + srcrc.h);
-		glVertex2f  (m_offsx + dst.x + dst.w,  m_offsy + dst.y + dst.h);
-		//  bottom-left
-		glTexCoord2i(srcrc.x,           srcrc.y + srcrc.h);
-		glVertex2f  (m_offsx + dst.x,   m_offsy + dst.y + dst.h);
-	} glEnd();
-
-	glLoadIdentity();
-}
-
-#endif //USE_OPENGL

=== modified file 'src/graphic/render/render_sdl.cc'
--- src/graphic/render/render_sdl.cc	2010-11-01 22:37:46 +0000
+++ src/graphic/render/render_sdl.cc	2010-11-29 19:01:16 +0000
@@ -49,7 +49,7 @@
  * Updating the whole Surface
  */
 void SurfaceSDL::update() {
-	if (m_surf_type == SURFACE_SCREEN) {
+	if (m_isscreen) {
 		//flip defaults to SDL_UpdateRect(m_surface, 0, 0, 0, 0);
 		SDL_Flip(m_surface);
 		//log("SurfaceSDL::update(): update complete screen\n");
@@ -128,7 +128,7 @@
 
 	const Point bl = rc.bottom_left();
 
-	lock();
+	lock(IPixelAccess::Lock_Normal);
 
 	if (m_surface->format->BytesPerPixel == 4)
 	{
@@ -183,7 +183,7 @@
 				SDL_MapRGB(m_surface->format, r, g, b);
 		}
 	}
-	unlock();
+	unlock(IPixelAccess::Unlock_Update);
 }
 
 #define draw_pixel(p, r, clr)                                                 \
@@ -257,24 +257,35 @@
 
 
 void SurfaceSDL::blit
-	(Point const dst, Surface * const src, Rect const srcrc, bool enable_alpha)
+	(Point const dst, PictureID src, Rect const srcrc, Composite cm)
 {
-	assert(src);
+	upcast(SurfaceSDL, sdlsurf, src.get());
+	assert(sdlsurf);
 	assert(this);
 	SDL_Rect srcrect = {srcrc.x, srcrc.y, srcrc.w, srcrc.h};
 	SDL_Rect dstrect = {dst.x, dst.y, 0, 0};
 
-	SDL_BlitSurface
-		(dynamic_cast<SurfaceSDL *>(src)->get_sdl_surface(),
-		 &srcrect, m_surface, &dstrect);
+	bool alpha;
+	uint8_t alphaval;
+	if (cm == CM_Solid || cm == CM_Copy) {
+		alpha = sdlsurf->get_sdl_surface()->flags & SDL_SRCALPHA;
+		alphaval = sdlsurf->get_sdl_surface()->format->alpha;
+		SDL_SetAlpha(sdlsurf->get_sdl_surface(), 0, 0);
+	}
+
+	SDL_BlitSurface(sdlsurf->get_sdl_surface(), &srcrect, m_surface, &dstrect);
+
+	if (cm == CM_Solid || cm == CM_Copy) {
+		SDL_SetAlpha(sdlsurf->get_sdl_surface(), alpha?SDL_SRCALPHA:0, alphaval);
+	}
 }
 
 
 /*
  * Fast blit, simply copy the source to the destination
  */
-void SurfaceSDL::fast_blit(Surface * const src) {
+void SurfaceSDL::fast_blit(PictureID const src) {
 	SDL_BlitSurface
-		(dynamic_cast<SurfaceSDL *>(src)->get_sdl_surface(),
+		(dynamic_cast<SurfaceSDL *>(src.get())->get_sdl_surface(),
 		 0, m_surface, 0);
 }

=== removed file 'src/graphic/render/surface_opengl.cc'
--- src/graphic/render/surface_opengl.cc	2010-11-01 22:37:46 +0000
+++ src/graphic/render/surface_opengl.cc	1970-01-01 00:00:00 +0000
@@ -1,381 +0,0 @@
-/*
- * Copyright 2010 by the Widelands Development Team
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include "surface_opengl.h"
-#include "log.h"
-#include "graphic/graphic.h"
-
-#include <cassert>
-#include <cmath>
-
-#ifdef USE_OPENGL
-
-long unsigned int pix_used = 0;
-long unsigned int pix_aloc = 0;
-long unsigned int num_tex = 0;
-
-#define handle_glerror() _handle_glerror(__FILE__, __LINE__)
-
-SDL_PixelFormat * rgbafmt = 0;
-
-/* handle_glerror() is intended to make debugging of oengl easier. It logs the
- * error code returned by glGetError and returns the error code.
- */
-GLenum _handle_glerror(const char * file, unsigned int line)
-{
-	GLenum err = glGetError();
-#ifdef DEBUG
-	if (err == GL_NO_ERROR)
-		return err;
-
-	log("%s:%d: OpenGL ERROR: ", file, line);
-
-	switch (err)
-	{
-	case GL_INVALID_VALUE:
-		log("invalid value\n");
-		break;
-	case GL_INVALID_ENUM:
-		log("invalid enum\n");
-		break;
-	case GL_INVALID_OPERATION:
-		log("invalid operation\n");
-		break;
-	case GL_STACK_OVERFLOW:
-		log("stack overflow\n");
-		break;
-	case GL_STACK_UNDERFLOW:
-		log("stack undeflow\n");
-		break;
-	case GL_OUT_OF_MEMORY:
-		log("out of memory\n");
-		break;
-	case GL_TABLE_TOO_LARGE:
-		log("table too large\n");
-		break;
-	default:
-		log("unknown\n");
-	}
-#endif
-	return err;
-}
-
-SurfaceOpenGL::SurfaceOpenGL(SDL_Surface & par_surface):
-	Surface(par_surface.w, par_surface.h, SURFACE_SOURCE),
-	m_glTexUpdate(false),
-	m_pixels     (0),
-	m_locked(false)
-{
-	GLuint texture;
-	SDL_Surface * surface;
-	GLenum pixels_format, pixels_type;
-	GLint  Bpp;
-
-	handle_glerror();
-
-	surface = &par_surface;
-
-	if (g_gr->caps().gl.tex_power_of_two)
-	{
-		int wexp = log(static_cast<float>(surface->w)) / log(2.0f);
-		int hexp = log(static_cast<float>(surface->h)) / log(2.0f);
-		if (pow(2.0f, wexp) < surface->w)
-			wexp++;
-		if (pow(2.0f, hexp) < surface->h)
-			hexp++;
-
-		m_tex_w = pow(2.0f, wexp);
-		m_tex_h = pow(2.0f, hexp);
-	} else {
-		m_tex_w = surface->w;
-		m_tex_h = surface->h;
-	}
-
-	if
-		(surface->format->palette or (surface->format->colorkey > 0) or
-		 m_tex_w != static_cast<uint32_t>(surface->w) or
-		 m_tex_h != static_cast<uint32_t>(surface->h))
-	{
-		//log("SurfaceOpenGL: convert surface for opengl\n");
-		surface = SDL_CreateRGBSurface
-			(SDL_SWSURFACE, m_tex_w, m_tex_h,
-			 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
-		assert(surface);
-		//SDL_DisplayFormatAlpha(&par_surface);
-		SDL_SetAlpha(surface, 0, 0);
-		SDL_SetAlpha(&par_surface, 0, 0);
-		SDL_BlitSurface(&par_surface, 0, surface, 0);
-		SDL_FreeSurface(&par_surface);
-	}
-
-	SDL_PixelFormat const & fmt = *surface->format;
-	Bpp = fmt.BytesPerPixel;
-
-	/* log
-		("SurfaceOpenGL::SurfaceOpenGL(SDL_Surface) Size: (%d, %d) %db(%dB) ",
-		 m_tex_w, m_tex_h,
-		 fmt.BitsPerPixel, Bpp);
-	log("R:%X, G:%X, B:%X, A:%X", fmt.Rmask, fmt.Gmask, fmt.Bmask, fmt.Amask); */
-
-	glPushAttrib(GL_PIXEL_MODE_BIT);
-	bool pushed = not (handle_glerror() == GL_STACK_OVERFLOW);
-
-	if (Bpp == 4)
-	{
-		if
-			(fmt.Rmask == 0x000000ff and fmt.Gmask == 0x0000ff00 and
-			 fmt.Bmask == 0x00ff0000)
-		{
-			if (fmt.Amask == 0xff000000)
-			{
-				pixels_format = GL_RGBA; //log(" RGBA 8888 ");
-			} else {
-				pixels_format = GL_RGBA; //log(" RGB 8880 ");
-				// Read four bytes per pixel but ignore the alpha value
-				glPixelTransferi(GL_ALPHA_SCALE, 0.0f);
-				glPixelTransferi(GL_ALPHA_BIAS, 1.0f);
-			}
-		} else if
-			(fmt.Bmask == 0x000000ff and fmt.Gmask == 0x0000ff00 and
-			 fmt.Rmask == 0x00ff0000)
-		{
-			if (fmt.Amask == 0xff000000)
-			{
-				pixels_format = GL_BGRA; //log(" BGRA 8888 ");
-			} else {
-				pixels_format = GL_BGRA; //log(" BGR 8880 ");
-				// Read four bytes per pixel but ignore the alpha value
-				glPixelTransferi(GL_ALPHA_SCALE, 0.0f);
-				glPixelTransferi(GL_ALPHA_BIAS, 1.0f);
-			}
-		} else
-			throw wexception("OpenGL: Unknown pixel format");
-		pixels_type = GL_UNSIGNED_BYTE;
-	} else if (Bpp == 3)
-	{
-		if
-			(fmt.Rmask == 0x000000ff and fmt.Gmask == 0x0000ff00 and
-			 fmt.Bmask == 0x00ff0000)
-		{
-			pixels_format = GL_RGB; //log(" RGB 888 ");
-		} else if
-			(fmt.Bmask == 0x000000ff and fmt.Gmask == 0x0000ff00 and
-			 fmt.Rmask == 0x00ff0000)
-		{
-			pixels_format = GL_BGR; //log(" BGR 888 ");
-		} else
-			throw wexception("OpenGL: Unknown pixel format");
-		pixels_type = GL_UNSIGNED_BYTE;
-	} else if (Bpp == 2)
-	{
-		if (fmt.Rmask == 0xF800 and fmt.Gmask == 0x7E0 and fmt.Bmask == 0x1F)
-		{
-			pixels_format = GL_RGB; //log(" RGB 565");
-		} else if
-			(fmt.Bmask == 0xF800 and fmt.Gmask == 0x7E0 and fmt.Rmask == 0x1F)
-		{
-			pixels_format = GL_BGR; //log(" BGR 565");
-		} else
-			assert(false);
-		pixels_type = GL_UNSIGNED_SHORT_5_6_5;
-	} else
-		throw wexception("OpenGL: Unknown pixel format");
-	//log("\n");
-
-	// Let OpenGL create a texture object
-	glGenTextures(1, &texture);
-	handle_glerror();
-
-	// select the texture object
-	glBindTexture(GL_TEXTURE_2D, texture);
-	handle_glerror();
-
-	// set texture filter to use linear filtering. This looks nicer for resized
-	// texture. Most textures and images are not resized so the filtering
-	// makes no difference
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	handle_glerror();
-
-	SDL_LockSurface(surface);
-
-	// glTexImage2D creates the texture of size (m_tex_w x m_tex_h) and copies
-	// the pixels for surface->pixels to it.
-	// The third parameter (internal format) specifies how opengl should store
-	//   the pixels. This has nothing to do with the read pixels
-	// 7th and 8th parameter (format and type) specify the format of the read
-	//   pixels (9th parameter)
-	glTexImage2D
-		(GL_TEXTURE_2D, 0, WL_GLINTERNALFORMAT, m_tex_w, m_tex_h, 0,
-		 pixels_format, pixels_type, surface->pixels);
-	handle_glerror();
-
-	if (pushed)
-		glPopAttrib();
-
-	SDL_UnlockSurface(surface);
-	SDL_FreeSurface(surface);
-
-	pix_used += m_w * m_h;
-	pix_aloc += m_tex_w * m_tex_h;
-	num_tex++;
-	/*
-	log
-		("texture stats: num: %lu, used: %lu (%luM), "
-		 "alocated: %lu (%luM) ++\n",
-		 num_tex, pix_used * 4, pix_used * 4 / (1024 * 1024),
-		 pix_aloc * 4, pix_aloc * 4/ (1024 * 1024));
-	*/
-	assert(glIsTexture(texture));
-
-	m_texture = new oglTexture(texture);
-	m_glTexUpdate = false;
-}
-
-
-SurfaceOpenGL::~SurfaceOpenGL() {
-	if (m_texture) {
-		pix_used -= m_w * m_h;
-		pix_aloc -= m_tex_w * m_tex_h;
-		num_tex--;
-		delete m_texture;
-	}
-	/* log
-		("~SurfaceOpenGL(): texture stats: num: %lu, "
-		 "used: %lu (%luM), alocated: %lu (%luM) --\n",
-		 num_tex, pix_used * 4, pix_used * 4 / (1024 * 1024),
-		 pix_aloc * 4, pix_aloc * 4/ (1024 * 1024)); */
-
-	delete[] m_pixels;
-}
-
-
-SurfaceOpenGL::SurfaceOpenGL(int const w, int const h):
-	Surface(w, h, SURFACE_SOURCE),
-	m_texture(0),
-	m_glTexUpdate(false),
-	m_pixels     (0),
-	m_locked(false)
-{
-	if (g_gr and g_gr->caps().gl.tex_power_of_two) {
-		//  Some old graphics cards support only opengl textures which have a
-		//  size of 2^n. To get it working on these cards we take the next equal
-		//  or greater power of two. This is a waste of graphics memory and
-		//  causes some problem with borders of textures and repeated textures
-		//  but at least it works.
-		int wexp = log(static_cast<float>(w)) / log(2.0f);
-		int hexp = log(static_cast<float>(h)) / log(2.0f);
-		if (pow(2.0f, wexp) < w)
-			wexp++;
-		if (pow(2.0f, hexp) < h)
-			hexp++;
-
-		m_tex_w = pow(2.0f, wexp);
-		m_tex_h = pow(2.0f, hexp);
-	} else {
-		m_tex_w = w;
-		m_tex_h = h;
-	}
-}
-
-/* This returns a SDL_Pixel format for the returned pixels. lock() copies the
- * pixels always as 32Bit RGBA. So we create and return a RGBA SDL_PixelFormat
- */
-const SDL_PixelFormat * SurfaceOpenGL::get_format() const
-{
-	if (rgbafmt)
-		return rgbafmt;
-	rgbafmt = new SDL_PixelFormat;
-	rgbafmt->BitsPerPixel = 32;
-	rgbafmt->BytesPerPixel = 4;
-	rgbafmt->Rmask = 0x000000ff; rgbafmt->Gmask = 0x0000ff00;
-	rgbafmt->Bmask = 0x00ff0000; rgbafmt->Amask = 0xff000000;
-	rgbafmt->Ashift = 24; rgbafmt->Bshift = 16; rgbafmt->Gshift = 8;
-	rgbafmt->Rshift = 0; rgbafmt->palette = 0;
-	return rgbafmt;
-}
-
-/* lock the surface for pixel access. This allocates memory and copies the
- * pixles from opengl texture to it. This copies the whole texture even if
- * only one pixel is read. So use this as rare as possible.
- */
-void SurfaceOpenGL::lock() {
-	if (m_locked)
-		return;
-	try {
-		if (m_surf_type == SURFACE_SCREEN)
-			m_pixels = new uint8_t[m_w * m_h * 4];
-		else
-			m_pixels = new uint8_t[m_tex_w * m_tex_h * 4];
-	} catch (std::bad_alloc) {
-		return;
-	}
-	if (m_surf_type == SURFACE_SCREEN)
-		glReadPixels
-			(0, 0, m_w, m_h, GL_RGBA, GL_UNSIGNED_BYTE, m_pixels);
-	else if (m_texture) {
-		assert(glIsTexture(m_texture->id()));
-		glBindTexture(GL_TEXTURE_2D, m_texture->id());
-		glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_pixels);
-		m_glTexUpdate = false;
-	} else
-		m_glTexUpdate = true;
-	//log("locked opengl surface(%d, %d)\n", m_tex_w, m_tex_h);
-	m_locked = true;
-}
-
-/* Unlock the surface after pixel access. This loads the pixels to the texture
- * if pixels were changed and free the alocated memory.
- */
-void SurfaceOpenGL::unlock() {
-	if (not m_locked)
-		return;
-	assert(m_pixels);
-
-	if (m_glTexUpdate) {
-		assert(m_surf_type != SURFACE_SCREEN);
-		if (!m_texture)
-		{
-			GLuint texture;
-			glGenTextures(1, &texture);
-
-			// selcet the texture object
-			glBindTexture(GL_TEXTURE_2D, texture);
-
-			// set texture filter to siply take the nearest pixel.
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-
-			pix_used += m_w * m_h;
-			pix_aloc += m_tex_w * m_tex_h;
-			num_tex++;
-
-			m_texture = new oglTexture(texture);
-		}
-		glBindTexture(GL_TEXTURE_2D, m_texture->id());;
-		glTexImage2D
-			(GL_TEXTURE_2D, 0, WL_GLINTERNALFORMAT, m_tex_w, m_tex_h, 0, GL_RGBA,
-			 GL_UNSIGNED_BYTE,  m_pixels);
-	}
-
-	delete [] m_pixels;
-	m_pixels = 0;
-	m_locked = false;
-}
-
-#endif //USE_OPENGL

=== removed file 'src/graphic/render/surface_opengl.h'
--- src/graphic/render/surface_opengl.h	2010-11-01 22:37:46 +0000
+++ src/graphic/render/surface_opengl.h	1970-01-01 00:00:00 +0000
@@ -1,170 +0,0 @@
-/*
- * Copyright 2010 by the Widelands Development Team
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#if !defined(SURFACE_OPENGL_H) and defined(USE_OPENGL)
-#define SURFACE_OPENGL_H
-
-#include "rgbcolor.h"
-#include "rect.h"
-#include "graphic/surface.h"
-
-#include <SDL_opengl.h>
-
-#include <cassert>
-
-#define WL_GLINTERNALFORMAT GL_RGBA
-
-namespace Widelands {
-struct Editor_Game_Base;
-struct Field;
-struct Player;
-}
-
-namespace UI {
-struct Font_Handler;
-}
-
-struct Vertex;
-
-/**
- * This implements OpenGL rendering. Do not use this class directly. The right
- * way is to use the base class Surface wherever possible. Everything which
- * needs to know about the underlying renderer should go to the graphics
- * subdirectory.
- * Surfaces are created through Graphic::create_surface() functions.
-*/
-class SurfaceOpenGL : public Surface {
-public:
-	/**
-	 * Manages a single OpenGL texture. This makes sure the texture is
-	 * freed when the object is destroyed.
-	*/
-	struct oglTexture {
-		oglTexture() {}
-		oglTexture(GLuint id): m_textureID(id) {}
-		~oglTexture() {glDeleteTextures(1, &m_textureID);}
-		GLuint id() const {return m_textureID;}
-	private:
-		GLuint m_textureID;
-	};
-
-	SurfaceOpenGL(SDL_Surface & surface);
-	explicit SurfaceOpenGL(int w = 0, int h = 0);
-	~SurfaceOpenGL();
-
-	//@{
-	/// Get width and height
-	uint32_t get_w() const {return m_w;}
-	uint32_t get_h() const {return m_h;}
-	uint32_t get_tex_w() const {return m_tex_w;}
-	uint32_t get_tex_h() const {return m_tex_h;}
-	//@}
-
-	void update();
-
-	GLuint get_texture() const
-	{
-#if defined(DEBUG)
-		if (m_surf_type != SURFACE_SOURCE)
-			throw wexception
-				("Try to get opengl texture id but not a source surface");
-		if (not m_texture)
-			throw wexception("no texture");
-#endif
-		return m_texture->id();
-	}
-
-	const SDL_PixelFormat * get_format() const;
-	SDL_PixelFormat const & format() const {return *get_format();}
-
-	/// Directly access the pixels. This is only valid if the surface is locked
-	inline uint16_t get_pitch() const {return m_tex_w * 4;}
-	uint8_t * get_pixels() const
-	{
-		assert(m_locked);
-		assert(m_pixels);
-		return m_pixels;
-	}
-
-	/// Lock: The Surface need to be locked before get or set pixel
-	void lock();
-	void unlock();
-
-	/// For the slowest: Indirect pixel access
-	inline uint32_t get_pixel(uint32_t x, uint32_t y) {
-		x += m_offsx;
-		y += m_offsy;
-
-		assert(x < get_w());
-		assert(y < get_h());
-		assert(m_locked);
-
-		return *reinterpret_cast<uint32_t *>(m_pixels + y * get_pitch() + x * 4);
-	}
-	inline void set_pixel(uint32_t x, uint32_t y, Uint32 clr) {
-		x += m_offsx;
-		y += m_offsy;
-
-		assert(x < get_w());
-		assert(y < get_h());
-		assert(m_locked);
-		m_glTexUpdate = true;
-
-		*reinterpret_cast<uint32_t *>(m_pixels + y * get_pitch() + x * 4) = clr;
-	}
-
-	void clear();
-	void draw_rect(Rect, RGBColor);
-	void fill_rect(Rect, RGBAColor);
-	void brighten_rect(Rect, int32_t factor);
-
-	void draw_line
-		(int32_t x1, int32_t y1,
-		 int32_t x2, int32_t y2,
-		 RGBColor, Rect const * clip = 0);
-
-	void blit(Point, Surface *, Rect srcrc, bool enable_alpha = true);
-	void blit(Rect dst, Surface *, Rect srcrc, bool enable_alpha = true);
-	//void fast_blit(Surface *);
-
-	oglTexture & getTexture() {return *m_texture;}
-
-private:
-	SurfaceOpenGL & operator= (SurfaceOpenGL const &);
-	explicit SurfaceOpenGL    (SurfaceOpenGL const &);
-
-	/// stores the opengl texture id and frees if destroyed
-	oglTexture * m_texture;
-	/// Indicates that the texture needs to be updated after pixel access
-	bool m_glTexUpdate;
-
-	//@{
-	/// set/unset a clipping rectangle
-	void set_subwin(Rect r);
-	void unset_subwin();
-	//@}
-
-	uint8_t * m_pixels;
-	bool m_locked;
-
-	/// Keep the size of the opengl texture. This is necessary because some
-	/// systems support only a power of two for texture sizes.
-	uint32_t m_tex_w, m_tex_h;
-};
-
-#endif

=== modified file 'src/graphic/render/surface_sdl.cc'
--- src/graphic/render/surface_sdl.cc	2010-05-18 13:21:05 +0000
+++ src/graphic/render/surface_sdl.cc	2010-11-29 19:01:16 +0000
@@ -25,7 +25,7 @@
 
 SurfaceSDL::~SurfaceSDL() {
 	//log("SurfaceSDL::~SurfaceSDL()\n");
-	if (m_surface and m_surf_type != SURFACE_SCREEN)
+	if (m_surface and !m_isscreen)
 		SDL_FreeSurface(m_surface);
 }
 
@@ -58,12 +58,12 @@
 		m_offsx * m_surface->format->BytesPerPixel;
 }
 
-void SurfaceSDL::lock() {
+void SurfaceSDL::lock(LockMode) {
 	if (SDL_MUSTLOCK(m_surface))
 		SDL_LockSurface(m_surface);
 }
 
-void SurfaceSDL::unlock() {
+void SurfaceSDL::unlock(UnlockMode) {
 	if (SDL_MUSTLOCK(m_surface))
 		SDL_UnlockSurface(m_surface);
 }
@@ -147,3 +147,8 @@
 	m_w = m_surface->w;
 	m_h = m_surface->h;
 }
+
+void SurfaceSDL::set_isscreen(bool screen)
+{
+	m_isscreen = screen;
+}

=== modified file 'src/graphic/render/surface_sdl.h'
--- src/graphic/render/surface_sdl.h	2010-11-01 22:37:46 +0000
+++ src/graphic/render/surface_sdl.h	2010-11-29 19:01:16 +0000
@@ -23,7 +23,7 @@
 #include "rgbcolor.h"
 #include "rect.h"
 
-#include "graphic/surface.h"
+#include "graphic/offscreensurface.h"
 
 /**
 * This implements SDL rendering. Do not use this class directly. The right
@@ -32,17 +32,24 @@
 * subdirectory.
 * Surfaces are created through Graphic::create_surface() functions.
 */
-struct SurfaceSDL : public Surface {
+struct SurfaceSDL : IOffscreenSurface {
 	SurfaceSDL(SDL_Surface & surface) :
-		Surface(surface.w, surface.h, SURFACE_OFFSCREEN),
-		m_surface(&surface)
+		m_surface(&surface),
+		m_offsx(0), m_offsy(0),
+		m_w(surface.w), m_h(surface.h),
+		m_isscreen(false)
 	{}
 	SurfaceSDL():
-		Surface(),
-		m_surface(0)
+		m_surface(0),
+		m_offsx(0), m_offsy(0),
+		m_w(0), m_h(0),
+		m_isscreen(false)
 	{}
 	~SurfaceSDL();
 
+	virtual uint32_t get_w() {return m_w;}
+	virtual uint32_t get_h() {return m_h;}
+
 	/// Set surface, only call once
 	void set_sdl_surface(SDL_Surface & surface);
 	SDL_Surface * get_sdl_surface() {return m_surface;}
@@ -53,21 +60,13 @@
 	/// Save a bitmap of this to a file
 	void save_bmp(const char & fname) const;
 
-/*
-	// For the bravest: Direct Pixel access. Use carefully
-	/// Needed if you want to blit directly to the screen by memcpy
-	void force_disable_alpha();
-	const SDL_PixelFormat * get_format() const;
-	uint16_t get_pitch() const {return m_surface->pitch;}
-*/
-
 	SDL_PixelFormat const & format() const;
 	uint8_t * get_pixels() const;
 	uint16_t get_pitch() const {return m_surface->pitch;}
 
 	/// Lock
-	void lock();
-	void unlock();
+	void lock(LockMode);
+	void unlock(UnlockMode);
 
 	/// For the slowest: Indirect pixel access
 	uint32_t get_pixel(uint32_t x, uint32_t y);
@@ -83,17 +82,27 @@
 		 int32_t x2, int32_t y2,
 		 RGBColor, Rect const * clip = 0);
 
-	void blit(Point, Surface *, Rect srcrc, bool enable_alpha = true);
-	void fast_blit(Surface *);
+	void blit(Point, PictureID, Rect srcrc, Composite cm);
+	void fast_blit(PictureID);
 
 	void set_subwin(Rect r);
 	void unset_subwin();
 
+	void set_isscreen(bool screen);
+
+	bool valid() {return m_surface;}
+
+	virtual IPixelAccess & pixelaccess() {return *this;}
+
 private:
 	SurfaceSDL & operator= (SurfaceSDL const &);
 	explicit SurfaceSDL    (SurfaceSDL const &);
 
 	SDL_Surface * m_surface;
+	int32_t m_offsx;
+	int32_t m_offsy;
+	uint32_t m_w, m_h;
+	bool m_isscreen;
 };
 
 #endif

=== modified file 'src/graphic/render/terrain_opengl.h'
--- src/graphic/render/terrain_opengl.h	2010-11-05 19:36:57 +0000
+++ src/graphic/render/terrain_opengl.h	2010-11-29 19:01:16 +0000
@@ -19,13 +19,12 @@
 
 #ifdef USE_OPENGL
 
-#include "surface_opengl.h"
+#include "gl_picture_texture.h"
 #include "vertex.h"
 
 
 void draw_field_opengl
-	(Surface & surf,
-	 Rect const & subwin,
+	(Rect const & subwin,
 	 Vertex const & p1,
 	 Vertex const & p2,
 	 Vertex const & p3,
@@ -122,11 +121,11 @@
 	uint8_t road;
 
 	GLuint rt_normal =
-		dynamic_cast<SurfaceOpenGL const &>
-		(*g_gr->get_road_texture(Widelands::Road_Normal)).get_texture();
+		dynamic_cast<GLPictureTexture const &>
+		(*g_gr->get_road_texture(Widelands::Road_Normal)).get_gl_texture();
 	GLuint rt_busy   =
-		dynamic_cast<SurfaceOpenGL const &>
-		(*g_gr->get_road_texture(Widelands::Road_Busy)).get_texture();
+		dynamic_cast<GLPictureTexture const &>
+		(*g_gr->get_road_texture(Widelands::Road_Busy)).get_gl_texture();
 
 	glDisable(GL_BLEND);
 	glColor4f(1.0f, 1.0f, 1.0f, 0.6f);

=== modified file 'src/graphic/render/terrain_sdl.h'
--- src/graphic/render/terrain_sdl.h	2010-11-05 19:36:57 +0000
+++ src/graphic/render/terrain_sdl.h	2010-11-29 19:01:16 +0000
@@ -23,6 +23,7 @@
 #include "constants.h"
 #include "log.h"
 #include "random.h"
+#include "upcast.h"
 #include "vertex.h"
 
 #include "wui/mapviewpixelconstants.h"
@@ -532,7 +533,7 @@
 }
 
 template<typename T> static void render_road_horiz
-	(SurfaceSDL & dst, Point const start, Point const end, Surface const & src)
+	(SurfaceSDL & dst, Point const start, Point const end, SurfaceSDL const & src)
 {
 	int32_t const dstw = dst.get_w();
 	int32_t const dsth = dst.get_h();
@@ -559,7 +560,7 @@
 }
 
 template<typename T> static void render_road_vert
-	(SurfaceSDL & dst, Point const start, Point const end, Surface const & src)
+	(SurfaceSDL & dst, Point const start, Point const end, SurfaceSDL const & src)
 {
 	int32_t const dstw = dst.get_w();
 	int32_t const dsth = dst.get_h();
@@ -597,10 +598,10 @@
 	 Texture const &  f_d_texture,
 	 Texture const &  f_r_texture)
 {
-	Surface const & rt_normal = *g_gr->get_road_texture(Widelands::Road_Normal);
-	Surface const & rt_busy   = *g_gr->get_road_texture(Widelands::Road_Busy);
+	upcast(SurfaceSDL, rt_normal, g_gr->get_road_texture(Widelands::Road_Normal).get());
+	upcast(SurfaceSDL, rt_busy, g_gr->get_road_texture(Widelands::Road_Busy).get());
 
-	dst.lock();
+	dst.lock(IPixelAccess::Lock_Normal);
 
 	render_triangle<T> (dst, f_vert, br_vert, r_vert, f_r_texture);
 	render_triangle<T> (dst, f_vert, bl_vert, br_vert, f_d_texture);
@@ -613,10 +614,10 @@
 		if (road) {
 			switch (road) {
 			case Widelands::Road_Normal:
-				render_road_horiz<T> (dst, f_vert, r_vert, rt_normal);
+				render_road_horiz<T> (dst, f_vert, r_vert, *rt_normal);
 				break;
 			case Widelands::Road_Busy:
-				render_road_horiz<T> (dst, f_vert, r_vert, rt_busy);
+				render_road_horiz<T> (dst, f_vert, r_vert, *rt_busy);
 				break;
 			default:
 				assert(false);
@@ -631,10 +632,10 @@
 		if (road) {
 			switch (road) {
 			case Widelands::Road_Normal:
-				render_road_vert<T> (dst, f_vert, br_vert, rt_normal);
+				render_road_vert<T> (dst, f_vert, br_vert, *rt_normal);
 				break;
 			case Widelands::Road_Busy:
-				render_road_vert<T> (dst, f_vert, br_vert, rt_busy);
+				render_road_vert<T> (dst, f_vert, br_vert, *rt_busy);
 				break;
 			default:
 				assert(false);
@@ -649,10 +650,10 @@
 		if (road) {
 			switch (road) {
 			case Widelands::Road_Normal:
-				render_road_vert<T> (dst, f_vert, bl_vert, rt_normal);
+				render_road_vert<T> (dst, f_vert, bl_vert, *rt_normal);
 				break;
 			case Widelands::Road_Busy:
-				render_road_vert<T> (dst, f_vert, bl_vert, rt_busy);
+				render_road_vert<T> (dst, f_vert, bl_vert, *rt_busy);
 				break;
 			default:
 				assert(false);
@@ -662,7 +663,7 @@
 		}
 	}
 
-	dst.unlock();
+	dst.unlock(IPixelAccess::Unlock_Update);
 
 	// FIXME: similar textures may not need dithering
 }

=== modified file 'src/graphic/rendertarget.cc'
--- src/graphic/rendertarget.cc	2010-06-14 19:31:37 +0000
+++ src/graphic/rendertarget.cc	2010-11-29 19:01:16 +0000
@@ -27,9 +27,7 @@
 #include "logic/tribe.h"
 #include "vertex.h"
 
-#include "surface.h"
-#include "graphic/render/surface_opengl.h"
-#include "graphic/render/surface_sdl.h"
+#include "offscreensurface.h"
 
 #include "log.h"
 #include "upcast.h"
@@ -43,16 +41,23 @@
 using Widelands::TCoords;
 
 /**
- * Build a render target for the given bitmap.
- * \note The bitmap will not be owned by the renderer, i.e. it won't be
- * deleted by the destructor.
+ * Build a render target for the given surface.
  */
-RenderTarget::RenderTarget(Surface * const bmp)
+RenderTarget::RenderTarget(SurfacePtr bmp)
 {
 	m_surface = bmp;
 	reset();
 }
 
+/**
+ * Build a render target for the given surface.
+ */
+RenderTarget::RenderTarget(OffscreenSurfacePtr surf)
+{
+	m_surface = surf;
+	reset();
+}
+
 
 /**
  * Sets an arbitrary drawing window.
@@ -178,108 +183,33 @@
 }
 
 /**
- * Blits a Surface on the screen or (if possible) on another Surface
- * Check g_gr->caps().offscreen_rendering to see if it is possible to blit
- * to a non screen surface.
- *
- * This blit function copies the pixels to the destination surface.
- * I the source surface contains a alpha channel this is used during
- * the blit.
- */
-void RenderTarget::blit(const Point dst, const PictureID picture)
-{
-	if (Surface * const src = g_gr->get_picture_surface(picture))
-		doblit
-			(Rect(dst, 0, 0),
-			 src, Rect(Point(0, 0), src->get_w(), src->get_h()));
-}
-
-/**
- * Blits a Surface on the screen or (if possible) on another Surface
- * Check g_gr->caps().offscreen_rendering to see if it is possible to blit
- * to a non screen surface.
- *
- * This blit function copies the pixels to the destination surface.
- * I the source surface contains a alpha channel this is used during
- * the blit.
- */
-void RenderTarget::blit(const Rect dst, const PictureID picture)
-{
-	if (Surface * const src = g_gr->get_picture_surface(picture))
-		doblit(dst, src, Rect(Point(0, 0), src->get_w(), src->get_h()));
-}
-
-/**
- * Blits a Surface on the screen or (if possible) on another Surface
- * Check g_gr->caps().offscreen_rendering to see if it is possible to blit
- * to a non screen surface.
- *
- * This blit function copies the pixels values without alpha channel to the
- * destination surface.
- */
-void RenderTarget::blit_solid(const Point dst, const PictureID picture)
-{
-	Surface * const src = g_gr->get_picture_surface(picture);
-	if (not src)
-		return;
-
-	upcast(SurfaceSDL, sdlsurf, src);
-	upcast(SurfaceOpenGL, oglsurf, src);
-
-	if (sdlsurf) {
-		bool alpha;
-		uint8_t alphaval;
-		alpha = sdlsurf->get_sdl_surface()->flags & SDL_SRCALPHA;
-		alphaval = sdlsurf->get_sdl_surface()->format->alpha;
-		SDL_SetAlpha(sdlsurf->get_sdl_surface(), 0, 0);
-		doblit
-			(Rect(dst, 0, 0),
-			 src, Rect(Point(0, 0), src->get_w(), src->get_h()), false);
-		SDL_SetAlpha(sdlsurf->get_sdl_surface(), alpha?SDL_SRCALPHA:0, alphaval);
-	} else if (oglsurf) {
-		doblit
-			(Rect(dst, 0, 0),
-			 src, Rect(Point(0, 0), src->get_w(), src->get_h()), false);
-	}
-}
-
-/**
- * Blits a Surface on the screen or (if possible) on another Surface
- * Check g_gr->caps().offscreen_rendering to see if it is possible to blit
- * to a non screen surface.
- *
- * This blit function copies the pixels (including alpha channel)
- * to the destination surface.
- * The destination pixels will be exactly like the source pixels.
- */
-void RenderTarget::blit_copy(Point dst, PictureID picture)
-{
-	Surface * const src = g_gr->get_picture_surface(picture);
-	upcast(SurfaceSDL, sdlsurf, src);
-	bool alpha;
-	uint8_t alphaval;
-	if (sdlsurf) {
-		alpha = sdlsurf->get_sdl_surface()->flags & SDL_SRCALPHA;
-		alphaval = sdlsurf->get_sdl_surface()->format->alpha;
-		SDL_SetAlpha(sdlsurf->get_sdl_surface(), 0, 0);
-	}
-	if (src)
-		doblit
-			(Rect(dst, 0, 0),
-			 src, Rect(Point(0, 0), src->get_w(), src->get_h()), false);
-	if (sdlsurf) {
-		SDL_SetAlpha(sdlsurf->get_sdl_surface(), alpha?SDL_SRCALPHA:0, alphaval);
-	}
-}
-
+ * Blits a Picture on the screen or (if possible) on another Surface
+ * Check g_gr->caps().offscreen_rendering to see if it is possible to blit
+ * to a non screen surface.
+ *
+ * This blit function copies the pixels to the destination surface.
+ * I the source surface contains a alpha channel this is used during
+ * the blit.
+ */
+void RenderTarget::blit(const Point dst, const PictureID picture, Composite cm)
+{
+	if (picture->valid())
+		doblit
+			(Rect(dst, 0, 0),
+			 picture, Rect(Point(0, 0), picture->get_w(), picture->get_h()), cm);
+}
+
+/**
+ * Like \ref blit, but use only a sub-rectangle of the source picture.
+ */
 void RenderTarget::blitrect
-	(Point const dst, PictureID const picture, Rect const srcrc)
+	(Point const dst, PictureID const picture, Rect const srcrc, Composite cm)
 {
 	assert(0 <= srcrc.x);
 	assert(0 <= srcrc.y);
 
-	if (Surface * const src = g_gr->get_picture_surface(picture))
-		doblit(Rect(dst, 0, 0), src, srcrc);
+	if (picture->valid())
+		doblit(Rect(dst, 0, 0), picture, srcrc, cm);
 }
 
 /**
@@ -288,24 +218,25 @@
  * The pixel from ofs inside picture is placed at the top-left corner of
  * the filled rectangle.
  */
-void RenderTarget::tile(Rect r, PictureID const picture, Point ofs)
+void RenderTarget::tile(Rect r, PictureID const picture, Point ofs, Composite cm)
 {
-	Surface * const src = g_gr->get_picture_surface(picture);
-
-	if (!src)
+	if (!picture->valid())
 		return;
 
+	int32_t srcw = picture->get_w();
+	int32_t srch = picture->get_h();
+
 	if (clip(r)) {
 		// Make sure the offset is within bounds
-		ofs.x = ofs.x % src->get_w();
+		ofs.x = ofs.x % srcw;
 
 		if (ofs.x < 0)
-			ofs.x += src->get_w();
+			ofs.x += srcw;
 
-		ofs.y = ofs.y % src->get_h();
+		ofs.y = ofs.y % srch;
 
 		if (ofs.y < 0)
-			ofs.y += src->get_h();
+			ofs.y += srch;
 
 		// Blit the picture into the rectangle
 		uint32_t ty = 0;
@@ -316,19 +247,19 @@
 			Rect srcrc;
 
 			srcrc.y = ofs.y;
-			srcrc.h = src->get_h() - ofs.y;
+			srcrc.h = srch - ofs.y;
 
 			if (ty + srcrc.h > r.h)
 				srcrc.h = r.h - ty;
 
 			while (tx < r.w) {
 				srcrc.x = tofsx;
-				srcrc.w = src->get_w() - tofsx;
+				srcrc.w = srcw - tofsx;
 
 				if (tx + srcrc.w > r.w)
 					srcrc.w = r.w - tx;
 
-				m_surface->blit(r + Point(tx, ty), src, srcrc);
+				m_surface->blit(r + Point(tx, ty), picture, srcrc, cm);
 
 				tx += srcrc.w;
 
@@ -372,7 +303,7 @@
 
 	// Get the frame and its data
 	uint32_t const framenumber = time / data->frametime % gfx->nr_frames();
-	Surface * const frame =
+	const PictureID & frame =
 		player ?
 		gfx->get_frame
 			(framenumber, player->player_number(), player->get_playercolor())
@@ -411,7 +342,7 @@
 
 	// Get the frame and its data
 	uint32_t const framenumber = time / data->frametime % gfx->nr_frames();
-	Surface * const frame =
+	const PictureID & frame =
 		player ?
 		gfx->get_frame
 			(framenumber, player->player_number(), player->get_playercolor())
@@ -486,14 +417,13 @@
  * Clip against window and source bitmap, then call the Bitmap blit routine.
  */
 void RenderTarget::doblit
-	(Rect dst, Surface * const src, Rect srcrc, bool enable_alpha)
+	(Point dst, PictureID src, Rect srcrc, Composite cm)
 {
 	assert(0 <= srcrc.x);
 	assert(0 <= srcrc.y);
 	dst += m_offset;
 
 	// Clipping
-
 	if (dst.x < 0) {
 		if (srcrc.w <= static_cast<uint32_t>(-dst.x))
 			return;
@@ -527,10 +457,5 @@
 
 	dst += m_rect;
 
-	// Draw it
-	upcast(SurfaceOpenGL, oglsurf, m_surface);
-	if (oglsurf and dst.w and dst.h)
-		oglsurf->blit(dst, src, srcrc, enable_alpha);
-	else
-		m_surface->blit(Point(dst.x, dst.y), src, srcrc, enable_alpha);
+	m_surface->blit(dst, src, srcrc, cm);
 }

=== modified file 'src/graphic/rendertarget.h'
--- src/graphic/rendertarget.h	2010-11-10 20:05:21 +0000
+++ src/graphic/rendertarget.h	2010-11-29 19:01:16 +0000
@@ -20,7 +20,9 @@
 #ifndef RENDERTARGET_H
 #define RENDERTARGET_H
 
+#include "compositemode.h"
 #include "picture_id.h"
+#include "surfaceptr.h"
 #include "rect.h"
 #include "rgbcolor.h"
 
@@ -29,7 +31,6 @@
 namespace Widelands {
 struct Player;
 };
-struct Surface;
 
 /**
  * This abstract class represents anything that can be rendered to.
@@ -47,7 +48,8 @@
  * false and doesn't change the window state at all.
 */
 struct RenderTarget {
-	RenderTarget(Surface *);
+	RenderTarget(SurfacePtr);
+	RenderTarget(OffscreenSurfacePtr);
 	RenderTarget(RenderTarget & rt):
 		m_surface(rt.m_surface),
 		m_rect(rt.m_rect),
@@ -70,12 +72,9 @@
 	void brighten_rect(Rect, int32_t factor);
 	void clear();
 
-	void blit(Point dst, PictureID picture);
-	void blit(Rect dst, PictureID picture);
-	void blit_solid(Point dst, PictureID picture);
-	void blit_copy(Point dst, PictureID picture);
-	void blitrect(Point dst, PictureID picture, Rect src);
-	void tile(Rect, PictureID picture, Point ofs);
+	void blit(Point dst, PictureID picture, Composite cm = CM_Normal);
+	void blitrect(Point dst, PictureID picture, Rect src, Composite cm = CM_Normal);
+	void tile(Rect, PictureID picture, Point ofs, Composite cm = CM_Normal);
 
 	void drawanim
 		(Point                     dst,
@@ -92,15 +91,15 @@
 
 	void reset();
 
-	Surface & get_surface() {return *m_surface;}
+	SurfacePtr get_surface() {return m_surface;}
 
 protected:
 	bool clip(Rect & r) const throw ();
 
-	void doblit(Rect dst, Surface * src, Rect srcrc, bool enable_alpha = true);
+	void doblit(Point dst, PictureID src, Rect srcrc, Composite cm = CM_Normal);
 
 	///The target surface
-	Surface * m_surface;
+	SurfacePtr m_surface;
 	///The current clip rectangle
 	Rect m_rect;
 	///Drawing offset

=== modified file 'src/graphic/surface.h'
--- src/graphic/surface.h	2010-11-01 22:37:46 +0000
+++ src/graphic/surface.h	2010-11-29 19:01:16 +0000
@@ -20,80 +20,28 @@
 #ifndef SURFACE_H
 #define SURFACE_H
 
+#include "compositemode.h"
 #include "rgbcolor.h"
 #include "rect.h"
+#include "surfaceptr.h"
 #include "wexception.h"
 
 /**
- * The type of a surface. This make it possible to check a bit before drawing.
+ * Interface to a basic surfaces that can be used as destination for drawing.
  */
-enum SurfaceType {
-	SURFACE_INVALID,
-	SURFACE_SOURCE,       ///< This sourface is used as source only
-	SURFACE_OFFSCREEN,    ///< Use surface as source and destinantion
-	SURFACE_SCREEN        ///< This draws to screen directly
-};
-
-/// A virtual base for rendering. Objects of Surface are used as Source or
-/// destination for drawing. Surfaces are created with the
-/// Graphic::create_surface() functions.
 struct Surface {
+	Surface() {}
 	virtual ~Surface() {}
 
 	//@{
 	/// Get width and height
-	virtual uint32_t get_w() const {return m_w;}
-	virtual uint32_t get_h() const {return m_h;}
+	virtual uint32_t get_w() = 0;
+	virtual uint32_t get_h() = 0;
 	//@}
 
 	/// Update the screen. This is only useful for the screen surface.
 	virtual void update() = 0;
 
-	//@{
-	/// For the slowest: Indirect pixel access.
-	/// A safe function to get and set single pixels. lock() must be called
-	/// before pixel access can be used. get_pixel() and set_pixel() are easier
-	/// and safer to use but also much slower than direct pixel access.
-	virtual uint32_t get_pixel(uint32_t x, uint32_t y) {
-		//  FIXME make abstract or move body out of declaration
-		throw wexception("get_pixel() not implemented");
-	}
-	virtual void set_pixel(uint32_t x, uint32_t y, Uint32 clr) {
-		//  FIXME make abstract or move body out of declaration
-		throw wexception("set_pixel() not implemented");
-	}
-	//@}
-
-	//@{
-	/**
-	 * Locking and unlocking the surface for pixel access. This may be slow. So
-	 * use it with care.
-	 */
-
-	virtual void lock() {};
-	virtual void unlock() {};
-	//@}
-
-	/// This returns the pixel format for direct pixel access.
-	virtual SDL_PixelFormat const & format() const {
-		throw wexception("format() not implemented");
-	}
-
-	//@{
-	/**
-	 * Direct pixel access. lock() must be called before pixles may be access.
-	 * This is faster than indirect pixel access but also more dangerous.
-	 * get_pixels() gives a pointer to the pixel data. get_pitch() returns an
-	 * integer where the next row begins.
-	 */
-	virtual uint16_t get_pitch() const {
-		throw wexception("get_pitch() not implemented");
-	}
-	virtual uint8_t * get_pixels() const {
-		throw wexception("get_pixels() not implemented");
-	}
-	//@}
-
 	/// Clears the complete surface to black.
 	virtual void clear() {
 		fill_rect
@@ -123,36 +71,16 @@
 	virtual void brighten_rect(Rect, int32_t factor) = 0;
 
 	/// This draws a part aother surface to this surface
-	virtual void blit(Point, Surface *, Rect srcrc, bool enable_alpha = false) = 0;
+	virtual void blit(Point, PictureID, Rect srcrc, Composite cm = CM_Normal) = 0;
 	/// This draws another surface completely in the left
 	/// upper corner of this surface
-	virtual void fast_blit(Surface * surface) {
-		blit
-			(Point(0, 0),
-			 surface,
-			 Rect(Point(0, 0), surface->get_w(), surface->get_h()));
-	}
-
-	/// set the type of the surface
-	virtual void set_type(SurfaceType const type) {m_surf_type = type;}
-
-protected:
-	int32_t m_offsx;
-	int32_t m_offsy;
-	uint32_t m_w, m_h;
-
-	Surface():
-		m_offsx(0), m_offsy(0),
-		m_w(0), m_h(0),
-		m_surf_type(SURFACE_INVALID)
-	{}
-	Surface(int w, int h, SurfaceType t):
-		m_offsx(0), m_offsy(0),
-		m_w(w), m_h(h),
-		m_surf_type(t)
-	{}
-	SurfaceType m_surf_type;
+	virtual void fast_blit(PictureID surface) = 0;
+
+	virtual IPixelAccess & pixelaccess() = 0;
+
 private:
+	// surfaces cannot be copied
+	Surface(const Surface &);
 	Surface & operator= (Surface const &);
 };
 

=== added file 'src/graphic/surfaceptr.h'
--- src/graphic/surfaceptr.h	1970-01-01 00:00:00 +0000
+++ src/graphic/surfaceptr.h	2010-11-29 19:01:16 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2010 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef SURFACEPTR_H
+#define SURFACEPTR_H
+
+#include <boost/shared_ptr.hpp>
+
+struct IOffscreenSurface;
+struct Surface;
+
+typedef boost::shared_ptr<IOffscreenSurface> OffscreenSurfacePtr;
+typedef boost::shared_ptr<Surface> SurfacePtr;
+
+#endif // SURFACEPTR_H

=== modified file 'src/graphic/texture.cc'
--- src/graphic/texture.cc	2010-11-21 11:44:22 +0000
+++ src/graphic/texture.cc	2010-11-29 19:01:16 +0000
@@ -102,14 +102,14 @@
 
 #ifdef USE_OPENGL
 		if (g_opengl) {
-			SurfaceOpenGL * tsurface =
-				&dynamic_cast<SurfaceOpenGL &>
-				(g_gr->load_image(fname));
-			// SDL_ConvertSurface(surf, &fmt, 0);
-			m_glFrames.push_back(tsurface);
-			tsurface->lock();
-			m_mmap_color = tsurface->get_pixel(0, 0);
-			tsurface->unlock();
+			// Note: we except the constructor to free the SDL surface
+			boost::shared_ptr<GLPictureTexture> surface(new GLPictureTexture(surf));
+			m_glFrames.push_back(surface);
+
+			surface->lock(IPixelAccess::Lock_Normal);
+			m_mmap_color = surface->get_pixel(0, 0);
+			surface->unlock(IPixelAccess::Unlock_NoChange);
+
 			++m_nrframes;
 			continue;
 		}
@@ -181,11 +181,6 @@
 	delete m_colormap;
 	free(m_pixels);
 	free(m_texture_picture);
-
-#ifdef USE_OPENGL
-	container_iterate(std::vector<SurfaceOpenGL *>, m_glFrames, it)
-		delete *it.current;
-#endif
 }
 
 /**

=== modified file 'src/graphic/texture.h'
--- src/graphic/texture.h	2010-11-01 22:37:46 +0000
+++ src/graphic/texture.h	2010-11-29 19:01:16 +0000
@@ -23,7 +23,7 @@
 #include "colormap.h"
 #include "picture_id.h"
 
-#include "graphic/render/surface_opengl.h"
+#include "graphic/render/gl_picture_texture.h"
 
 #include <boost/shared_ptr.hpp>
 #include <stdint.h>
@@ -65,7 +65,7 @@
 	bool was_animated() const throw () {return m_was_animated;}
 #ifdef USE_OPENGL
 	uint32_t getTexture() const
-		{return m_glFrames.at(m_frame_num)->get_texture();}
+		{return m_glFrames.at(m_frame_num)->get_gl_texture();}
 #endif
 
 private:
@@ -80,7 +80,7 @@
 	bool       is_32bit;
 	bool       m_was_animated;
 #ifdef USE_OPENGL
-	std::vector<SurfaceOpenGL *> m_glFrames;
+	std::vector<boost::shared_ptr<GLPictureTexture> > m_glFrames;
 #endif
 };
 

=== modified file 'src/map_io/widelands_map_extradata_data_packet.cc'
--- src/map_io/widelands_map_extradata_data_packet.cc	2010-05-12 10:16:44 +0000
+++ src/map_io/widelands_map_extradata_data_packet.cc	2010-11-29 19:01:16 +0000
@@ -75,20 +75,19 @@
 					if (!surf)
 						continue; //  Illegal pic. Skip it.
 
-					Surface & picsurf = g_gr->create_surface(*surf);
+					PictureID const picture = g_gr->convert_sdl_surface_to_picture(surf);
 
 					std::string picname = FileSystem::FS_Filename(pname->c_str());
 					picname = "map:" + picname;
 
-					PictureID const data =
-						g_gr->get_picture(PicMod_Game, picsurf, picname.c_str());
+					g_gr->add_picture_to_cache(PicMod_Game, picname, picture);
 
 					//  OK, the pic is now known to the game. But when the game is
 					//  saved, this data has to be regenerated.
 					Map::Extradata_Info info;
 					info.type     = Map::Extradata_Info::PIC;
 					info.filename = *pname;
-					info.data     = data;
+					info.data     = picture;
 					map.m_extradatainfos.push_back(info);
 				}
 			}

=== modified file 'src/ui_basic/button.cc'
--- src/ui_basic/button.cc	2010-11-01 23:32:46 +0000
+++ src/ui_basic/button.cc	2010-11-29 19:01:16 +0000
@@ -22,6 +22,7 @@
 #include "mouse_constants.h"
 
 #include "graphic/font_handler.h"
+#include "graphic/offscreensurface.h"
 #include "graphic/rendertarget.h"
 #include "wlapplication.h"
 #include "log.h"
@@ -48,7 +49,6 @@
 	m_repeating     (false),
 	m_flat          (flat),
 	m_needredraw    (true),
-	m_cache_pic     (g_gr->get_no_picture()),
 	m_title         (title_text),
 	m_pic_background(background_picture_id),
 	m_pic_custom    (g_gr->get_no_picture()),
@@ -81,7 +81,6 @@
 	m_repeating     (false),
 	m_flat          (flat),
 	m_needredraw    (true),
-	m_cache_pic     (g_gr->get_no_picture()),
 	m_pic_background(background_picture_id),
 	m_pic_custom    (foreground_picture_id),
 	m_pic_custom_disabled(g_gr->create_grayed_out_pic(foreground_picture_id)),
@@ -94,9 +93,8 @@
 }
 
 
-Button::~Button() {
-	if (m_pic_custom_disabled != g_gr->get_no_picture())
-		g_gr->free_picture_surface(m_pic_custom_disabled);
+Button::~Button()
+{
 }
 
 
@@ -113,8 +111,6 @@
 	m_needredraw = true;
 
 	m_pic_custom = picid;
-	if (m_pic_custom_disabled != g_gr->get_no_picture())
-		g_gr->free_picture_surface(m_pic_custom_disabled);
 	m_pic_custom_disabled = g_gr->create_grayed_out_pic(picid);
 
 	update();
@@ -168,7 +164,7 @@
 */
 void Button::draw(RenderTarget & odst)
 {
-	RenderTarget * dst = &odst;
+	RenderTarget dst = odst;
 
 	if (g_gr->caps().offscreen_rendering) {
 		if (!m_needredraw)
@@ -176,18 +172,15 @@
 			odst.blit(Point(0, 0), m_cache_pic);
 			return;
 		} else {
-			if (m_cache_pic == g_gr->get_no_picture())
-				m_cache_pic =
-					g_gr->create_picture_surface(get_w(), get_h(), m_flat);
-			else if
-				(m_cache_pic->rendertarget->get_w() != get_w() or
-				 m_cache_pic->rendertarget->get_h() != get_h())
+			if
+				(!m_cache_pic ||
+				 (static_cast<IPicture *>(m_cache_pic.get())->get_w() != static_cast<uint32_t>(get_w()) or
+				  static_cast<IPicture *>(m_cache_pic.get())->get_h() != static_cast<uint32_t>(get_h())))
 			{
-				g_gr->free_picture_surface(m_cache_pic);
 				m_cache_pic =
-					g_gr->create_picture_surface(get_w(), get_h(), m_flat);
+					g_gr->create_offscreen_surface(get_w(), get_h(), m_flat);
 			}
-			dst = (g_gr->get_surface_renderer(m_cache_pic));
+			dst = RenderTarget(m_cache_pic);
 		}
 	}
 
@@ -195,18 +188,18 @@
 	// Draw the background
 	if (not m_flat) {
 		assert(m_pic_background != g_gr->get_no_picture());
-		dst->fill_rect
+		dst.fill_rect
 			(Rect(Point(0, 0), get_w(), get_h()), RGBAColor(0, 0, 0, 255));
-		dst->tile
+		dst.tile
 			(Rect(Point(0, 0), get_w(), get_h()),
 			 m_pic_background,
 			 Point(get_x(), get_y()));
 	} else if (g_gr->caps().offscreen_rendering)
-		dst->fill_rect
+		dst.fill_rect
 			(Rect(Point(0, 0), get_w(), get_h()), RGBAColor(0, 0, 0, 0));
 
 	if (m_enabled and m_highlighted and not m_flat)
-		dst->brighten_rect
+		dst.brighten_rect
 			(Rect(Point(0, 0), get_w(), get_h()), MOUSE_OVER_BRIGHT_FACTOR);
 
 	//  if we got a picture, draw it centered
@@ -217,13 +210,14 @@
 		//  ">> 1" is almost like "/ 2", but simpler for signed types (difference
 		//  is that -1 >> 1 is -1 but -1 / 2 is 0).
 		if (g_gr->caps().offscreen_rendering and m_flat)
-			dst->blit_copy
+			dst.blit
 				(Point
 				 	((get_w() - static_cast<int32_t>(cpw)) >> 1,
 				 	 (get_h() - static_cast<int32_t>(cph)) >> 1),
-				 m_enabled ? m_pic_custom : m_pic_custom_disabled);
+				 m_enabled ? m_pic_custom : m_pic_custom_disabled,
+				 CM_Copy);
 		else
-			dst->blit
+			dst.blit
 				(Point
 				 	((get_w() - static_cast<int32_t>(cpw)) >> 1,
 				 	 (get_h() - static_cast<int32_t>(cph)) >> 1),
@@ -231,7 +225,7 @@
 
 	} else if (m_title.length()) //  otherwise draw title string centered
 		UI::g_fh->draw_string
-			(*dst,
+			(dst,
 			 m_fontname,
 			 m_fontsize,
 			 m_enabled ? UI_FONT_CLR_FG : UI_FONT_CLR_DISABLED, UI_FONT_CLR_BG,
@@ -240,7 +234,7 @@
 			 Align_Center,
 			 std::numeric_limits<uint32_t>::max(),
 			 Widget_Cache_None,
-			 g_gr->get_no_picture(),
+			 0,
 			 m_draw_caret ? m_title.length() :
 			 std::numeric_limits<uint32_t>::max());
 
@@ -260,32 +254,32 @@
 		//  button is a normal one, not flat
 		if (not draw_pressed) {
 			//  top edge
-			dst->brighten_rect
+			dst.brighten_rect
 				(Rect(Point(0, 0), get_w(), 2), BUTTON_EDGE_BRIGHT_FACTOR);