Merge lp:~nha/widelands/opengl into lp:widelands

[Nicolai Hähnle]

Rewrite the OpenGL renderer to be closer to OpenGL best practices. Using vertex arrays gets performance from < 0.5 fps to the point where OpenGL is no longer the bottleneck on at least my system. Tested both OpenGL and SDL rendering with a little bit of playing and editing.

Please take a quick look, in particular a quick test for regressions on different systems would be nice.

[Tino (tino79)]

It works fine on windows, just noticed:
- If i deactivate OpenGL in the Advanced Options menu->Apply->Apply -> Widelands quits, not stderr.txt
- If i active OpenGL via Options menu => Back to main menu, but no fonts, only white bars. I can quit widelands and then the updated config gets written. But if i load a game => crash.

Manually changing config works and Widelands runs fine in both modes. Only on-the-fly change does not.

[Nicolai Hähnle (nha)]

Could you please check whether you get the same crashes in current trunk? I remembered having one similar crash when switching between software and OpenGL before my changes, but unfortunately I didn't follow up because I thought there may be something driver-related going on.

[Tino (tino79)]

Sorry, you are right. The same problem occurs with a trunk build.
I am pretty sure it worked at some point before.

[Nicolai Hähnle (nha)]

Thank you so much for testing! Could you file a bug report for that so we don't forget about it?

[SirVer (sirver)]

Nicolai! The code compiles and runs great on later Mac OS X - I cannot check with old OS X as my wife took the laptop with her to work. The speedup is quite tremendous: on 100x speed terrain rendering takes less than 15% CPU now on my box. Superb work as always from you.

As you might have noticed we took up a review kind of process. The specifics are not clear yet - I just learned on my job that this can be very useful and improve the code significantly. So here are some comments:

- the diff here on the site is borked (it reports merge conflicts). Can you repropose? I think it updates the diff.
- adding the intensity parameter to the load() function seems suboptimal. First it is very specific to OpenGL rendering as SDL has no use for it. Secondly it gives the class a second task (namely loading and then 'flattening' the image). How about moving the edge/road loading and ownership out of graphic into the gameview renderer and giving only the GLTextures the intensity parameter. You could even make a conversion (static) method that could convert an RGB to an intensity texture - this would slow startup by a tad, but would keep this stuff internal to the (gl) terrain rendering - I feel that is a cleaner design.
- Some of the functions (e.g. drawobject(), but also others) are very long and repetitive? Can you find some seams to offload stuff into private or even better static methods/functions? I would not feel comfi to refactor anything in those methods as they stand now :)
- "and should be treated as read-only by derived classes": You made two pointers const, why not the third as well? How about not making those protected members, but instead combine them into a struct RenderState or so and pass this down to the functions doing the work? Your call.
- RenderTarget & dst: I prefer to pass a mutable object by pointer. The reason is that it becomes apparent on the call site if the call might modify the object or not. I realize that you prefer to use reference when an object must be passed (i.e. cannot be NULL), but i feel adding an assert as first line to the function does an equally good job. Your choice of course.
- I love MapviewPixelFunctions. I will wrap some of those for Lua (there are some values hard coded there).
- You pass Point by value regularly - why not use a const reference?
- GameRenderer is a struct, but should be a class. We started to run into trouble with clang complaining about the difference. We now use Class for anything with non trivial methods and struct otherwise. Sorry, you need to type the public: now :)

[Nicolai Hähnle (nha)]

> Nicolai! The code compiles and runs great on later Mac OS X - I cannot check with old OS X as my wife took the laptop with her to work. The speedup is quite tremendous: on 100x speed terrain rendering takes less than 15% CPU now on my box. Superb work as always from you.
Thank you.
> As you might have noticed we took up a review kind of process. The specifics are not clear yet - I just learned on my job that this can be very useful and improve the code significantly. So here are some comments:
>
> - the diff here on the site is borked (it reports merge conflicts). Can you repropose? I think it updates the diff.
Should be fixed now.
> - adding the intensity parameter to the load() function seems suboptimal. First it is very specific to OpenGL rendering as SDL has no use for it. Secondly it gives the class a second task (namely loading and then 'flattening' the image). How about moving the edge/road loading and ownership out of graphic into the gameview renderer and giving only the GLTextures the intensity parameter. You could even make a conversion (static) method that could convert an RGB to an intensity texture - this would slow startup by a tad, but would keep this stuff internal to the (gl) terrain rendering - I feel that is a cleaner design.
Loading the edge.png texture in GameRendererGL does make sense, though
then it would probably be best to make GameRendererGL a "singleton" to
avoid loading the texture multiple times. Or is your new image cache
meant to also cache textures provided by some other part of the code, so
that multiple instances of GameRendererGL would be using the same texture?
> - Some of the functions (e.g. drawobject(), but also others) are very long and repetitive? Can you find some seams to offload stuff into private or even better static methods/functions? I would not feel comfi to refactor anything in those methods as they stand now :)
I'll have to think about it. The problem is that a lot of that stuff is
inherently a two-pass approach.
> - "and should be treated as read-only by derived classes": You made two pointers const, why not the third as well?
The renderer is not supposed to modify egbase or player, but it _is_
supposed to modify the RenderTarget.
> How about not making those protected members, but instead combine them into a struct RenderState or so and pass this down to the functions doing the work? Your call.
> - RenderTarget & dst: I prefer to pass a mutable object by pointer. The reason is that it becomes apparent on the call site if the call might modify the object or not. I realize that you prefer to use reference when an object must be passed (i.e. cannot be NULL), but i feel adding an assert as first line to the function does an equally good job. Your choice of course.
So sigra's influence is in decline? I actually agree with you in
general, but I believe that most code still passes RenderTargets around
by reference and it's better to be consistent. Besides, it's usually
pretty obvious that you want RenderTargets to be modified.
> - I love MapviewPixelFunctions. I will wrap some of those for Lua (there are some values hard coded there).
> - You pass Point by value regularly - why not u...

[Nicolai Hähnle (nha)]

I adjusted the code based on your comments, except the road rendering which just seemed a bit too awkward to unify. Does get_dither_edge_texture fit with your concept of how the ImageCache is supposed to work?

[SirVer (sirver)]

Not sure if the code in the diff is up to date again... I did a bzr merge and looked at my local copy.

Responses:
> So sigra's influence is in decline?
Erik has not been around for a long time now. He started a job and
mentioned some years back that this will likely make it hard for him to
continue on widelands. I wouldn't say that is 'influence is in decline',
we just develop, learn and change :)

> I actually agree with you in general, but I believe that most code still
>passes RenderTargets around by reference and it's better to be
>consistent. Besides, it's usually pretty obvious that you want
>RenderTargets to be modified.
Ack.

About get_dither_edge_texture: Yes, approximately. I pushed a branch for merging - I think what you want here is a new TransformedImage or directly using the SurfaceCache. I pushed my branch for review just now, so you can have a look at my design. As you were quicker with the merge proposal though, the fun of fixing the merge conflicts is on me, I guess.

Nitpicking:
- Widelands::Editor_Game_Base const &. Prefer to put const in front, more similar to a pointer. Same for other objects of course.
- class GameRenderer. Make boost::noncopyable?
- in some places inside function you could use const for variables more
  aggressively. This would give the compiler a better chance to
  optimise.
- What about the dynamic_casts? Why not static, we should know the types
  in all cases, right?
- assert(sizeof(basevertex) == 32); We have a compile assert statement
  for this somewhere.

These are just nits from my point of view. So I am completely fine with
merging this as is. Can you do the merge or should I - just remember to
never push your branch to trunk, always merge into trunk and push that.

review: Approve

[SirVer (sirver)]

Oh just as a comment: I will try to merge your and my branch in a new branch.

[SirVer (sirver)]

I merged our two branches in lp:~widelands-dev/widelands/opengl_and_autocache because I had time to do this today. I am not sure how to go forward now, though :). I do not want to redo the merge - it was quite a lot of work. Can we continue working on this joint branch?

As a sidenote, I am now going over this and do some of the fixes I suggested myself. I suggest for the future to always push to ~widelands-dev, so that the reviewer can do small fixes himself directly.

[SirVer (sirver)]

- I did fix the position of the const in const Klass&. I also added a style rule for this now (there are a lot of warnings in the rest of the code).
- Also added a boost::noncopyable to rendertarget.

[Nicolai Hähnle (nha)]

Nice, and thank you for merging those two branches! I have to run for now, so I would suggest you just do the merge into trunk whenever you're happy with it. Just some quick replies:

1. get_dither_edge_texture(): Since this is such a special case for now, I would just go directly to the SurfaceCache, but I don't have strong feelings about it. I haven't looked at your merge yet.

2. const-modifiers: Sigra was always very vocal about putting the const at the end, because that is more consistent with const-ness when you have pointers-to-pointers, and that just rubbed off a little bit onto me, but I have no strong feelings either way.

3. GameRenderer: Yes, should be boost::noncopyable, forgot about that.

4. const local variables: Compilers should be grown-up enough to be able to do optimizations themselves, but it does make sense to avoid future refactoring bugs.

5. Yes, those dynamic_casts could be static_casts, but it's not a performance critical path. In the spirit of defensive programming, one could leave it as is.

6. compile-time asserts: You're absolutely right about that.

[SirVer (sirver)]

1. I used the surface cache directly. I am a little unhappy that we copy and paste the image loading code here. I added a TODO for this which will let me sleep :-)

2. I do not understand this argument. const Klass* and const Klass& reads clearer to me. And you always read right to left. Oh well - mainly bikeshedding. I settled this for now by adding a new style checker rule. It reports > 1000 violations right now oO. Will see if I can get them fixed tonight.

3. done.
4. Couldn't be bothered for now to touch this. Just add as much const in as you can in the future. It makes life easier often (I just learned this at work basically).
5. Left as is. I trust you that it is not on timing critical paths.
6. done.

I did the fixes in the common branch and merged it into trunk. How cool is that: Widelands became faster, less demanding on the hardware and uses less memory and these improvements all came in one commit.

=== modified file '.bzrignore'
--- .bzrignore	2012-06-20 09:07:10 +0000
+++ .bzrignore	2013-02-09 12:25:26 +0000
@@ -23,3 +23,5 @@
 /tribes/**/*.xhtml
 /global/**/*.xhtml
 
+# Local KDevelop settings files
+**/.kdev_include_paths
 
=== modified file 'src/graphic/graphic.cc'
--- src/graphic/graphic.cc	2013-01-05 20:11:57 +0000
+++ src/graphic/graphic.cc	2013-02-09 12:25:26 +0000
@@ -238,8 +238,7 @@
 
 		m_caps.gl.multitexture =
 			 ((strstr(extensions, "GL_ARB_multitexture") != 0) and
-			  (strstr(extensions, "GL_ARB_texture_env_combine") != 0))
-			and (m_caps.gl.max_tex_combined >= 6);
+			  (strstr(extensions, "GL_ARB_texture_env_combine") != 0));
 		log("Graphics: OpenGL: Multitexture capabilities ");
 		log(m_caps.gl.multitexture ? "sufficient\n" : "insufficient, only basic terrain rendering possible\n");
 
@@ -971,10 +970,6 @@
 	m_roadtextures->pic_road_normal = imgcache().load(PicMod_Game, buf, false);
 	snprintf(buf, sizeof(buf), "worlds/%s/pics/roadt_busy.png", worldname.c_str());
 	m_roadtextures->pic_road_busy = imgcache().load(PicMod_Game, buf, false);
-
-	// load edge texture
-	snprintf(buf, sizeof(buf), "worlds/%s/pics/edge.png", worldname.c_str());
-	m_edgetexture = imgcache().load(PicMod_Game, buf, false);
 }
 
 /**
@@ -987,12 +982,3 @@
 	return
 		(roadtex == Widelands::Road_Normal ? m_roadtextures->pic_road_normal : m_roadtextures->pic_road_busy);
 }
-
-/**
- * Returns the alpha mask texture for edges.
- * \return The edge texture (alpha mask)
- */
-const IPicture* Graphic::get_edge_texture()
-{
-	return m_edgetexture;
-}
 
=== modified file 'src/graphic/graphic.h'
--- src/graphic/graphic.h	2013-01-05 18:52:13 +0000
+++ src/graphic/graphic.h	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002-2004, 2006-2012 by the Widelands Development Team
+ * Copyright (C) 2002-2004, 2006-2013 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
@@ -119,7 +119,8 @@
 
 	void save_png(const IPicture*, StreamWrite*) const;
 
-	virtual IPicture* convert_sdl_surface_to_picture(SDL_Surface *, bool alpha = false) const;
+	virtual IPicture* convert_sdl_surface_to_picture
+		(SDL_Surface *, bool alpha = false) const;
 
 	Surface* create_surface(int32_t w, int32_t h, bool alpha = false) const;
 
@@ -144,7 +145,6 @@
 
 	void set_world(std::string);
 	const IPicture* get_road_texture(int32_t roadtex);
-	const IPicture* get_edge_texture();
 
 	const GraphicCaps& caps() const throw () {return m_caps;}
 
@@ -178,7 +178,6 @@
 	/// stores which features the current renderer has
 	GraphicCaps m_caps;
 	Road_Textures * m_roadtextures;
-	const IPicture* m_edgetexture;
 	std::vector<Texture *> m_maptextures;
 	std::vector<AnimationGfx *> m_animations;
 
 
=== modified file 'src/graphic/igraphic.h'
--- src/graphic/igraphic.h	2012-12-15 18:40:59 +0000
+++ src/graphic/igraphic.h	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006-2012 by the Widelands Development Team
+ * Copyright (C) 2006-2013 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
@@ -32,7 +32,9 @@
 public:
 	virtual ~IGraphic() {};
 
-	virtual IPicture* convert_sdl_surface_to_picture(SDL_Surface*, bool alpha = false) const = 0;
+	virtual IPicture* convert_sdl_surface_to_picture
+		(SDL_Surface*,
+		 bool alpha = false) const = 0;
 	virtual IBlitableSurface * create_surface(int32_t w, int32_t h, bool alpha = false) const = 0;
 
 	virtual ImageCache& imgcache() const = 0;
 
=== modified file 'src/graphic/image_loader.h'
--- src/graphic/image_loader.h	2012-12-13 21:10:32 +0000
+++ src/graphic/image_loader.h	2013-02-09 12:25:26 +0000
@@ -34,4 +34,3 @@
 };
 
 #endif /* end of include guard: IMAGE_LOADER_H */
-
 
=== added file 'src/graphic/render/gamerenderer.cc'
--- src/graphic/render/gamerenderer.cc	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gamerenderer.cc	2013-02-09 12:25:26 +0000
@@ -0,0 +1,286 @@
+/*
+ * Copyright (C) 2010-2013 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#include "gamerenderer.h"
+
+#include "graphic/rendertarget.h"
+
+#include "logic/editor_game_base.h"
+#include "logic/player.h"
+
+#include "wui/mapviewpixelfunctions.h"
+#include "wui/overlay_manager.h"
+
+#include "upcast.h"
+
+using namespace Widelands;
+
+GameRenderer::GameRenderer()
+{
+}
+
+GameRenderer::~GameRenderer()
+{
+}
+
+void GameRenderer::rendermap
+	(RenderTarget & dst,
+	 Widelands::Editor_Game_Base const &       egbase,
+	 Widelands::Player           const &       player,
+	 Point                       const &       viewofs)
+{
+	m_dst = &dst;
+	m_dst_offset = -viewofs;
+	m_egbase = &egbase;
+	m_player = &player;
+
+	draw_wrapper();
+}
+
+void GameRenderer::rendermap
+	(RenderTarget & dst,
+	 Widelands::Editor_Game_Base const & egbase,
+	 Point                       const & viewofs)
+{
+	m_dst = &dst;
+	m_dst_offset = -viewofs;
+	m_egbase = &egbase;
+	m_player = 0;
+
+	draw_wrapper();
+}
+
+void GameRenderer::draw_wrapper()
+{
+	Point tl_map = m_dst->get_offset() - m_dst_offset;
+
+	assert(tl_map.x >= 0); // divisions involving negative numbers are bad
+	assert(tl_map.y >= 0);
+
+	m_minfx = tl_map.x / TRIANGLE_WIDTH - 1;
+	m_minfy = tl_map.y / TRIANGLE_HEIGHT - 1;
+	m_maxfx = (tl_map.x + m_dst->get_rect().w + (TRIANGLE_WIDTH / 2)) / TRIANGLE_WIDTH;
+	m_maxfy = (tl_map.y + m_dst->get_rect().h) / TRIANGLE_HEIGHT;
+
+	// fudge for triangle boundary effects and for height differences
+	m_minfx -= 1;
+	m_minfy -= 1;
+	m_maxfx += 1;
+	m_maxfy += 10;
+
+	draw();
+}
+
+void GameRenderer::draw_objects()
+{
+	static const uint32_t F = 0;
+	static const uint32_t R = 1;
+	static const uint32_t BL = 2;
+	static const uint32_t BR = 3;
+	Map const & map = m_egbase->map();
+
+	for (int32_t fy = m_minfy; fy <= m_maxfy; ++fy) {
+		for (int32_t fx = m_minfx; fx <= m_maxfx; ++fx) {
+			Coords ncoords(fx, fy);
+			map.normalize_coords(ncoords);
+			FCoords coords[4];
+			coords[F] = map.get_fcoords(ncoords);
+			coords[R] = map.r_n(coords[F]);
+			coords[BL] = map.bl_n(coords[F]);
+			coords[BR] = map.br_n(coords[F]);
+			Point pos[4];
+			MapviewPixelFunctions::get_basepix(Coords(fx, fy), pos[F].x, pos[F].y);
+			MapviewPixelFunctions::get_basepix(Coords(fx + 1, fy), pos[R].x, pos[R].y);
+			MapviewPixelFunctions::get_basepix(Coords(fx + (fy & 1) - 1, fy + 1), pos[BL].x, pos[BL].y);
+			MapviewPixelFunctions::get_basepix(Coords(fx + (fy & 1), fy + 1), pos[BR].x, pos[BR].y);
+			for (uint32_t d = 0; d < 4; ++d) {
+				pos[d].y -= coords[d].field->get_height() * HEIGHT_FACTOR;
+				pos[d] += m_dst_offset;
+			}
+
+			Player_Number owner_number[4];
+			bool isborder[4];
+			Vision vision[4] = {2, 2, 2, 2};
+			for (uint32_t d = 0; d < 4; ++d)
+				owner_number[d] = coords[d].field->get_owned_by();
+			for (uint32_t d = 0; d < 4; ++d)
+				isborder[d] = coords[d].field->is_border();
+
+			if (m_player && !m_player->see_all()) {
+				for (uint32_t d = 0; d < 4; ++d) {
+					Player::Field const & pf = m_player->fields()[map.get_index(coords[d], map.get_width())];
+					vision[d] = pf.vision;
+					if (pf.vision == 1) {
+						owner_number[d] = pf.owner;
+						isborder[d] = pf.border;
+					}
+				}
+			}
+
+			if (isborder[F]) {
+				Player const & owner = m_egbase->player(owner_number[F]);
+				uint32_t const anim = owner.frontier_anim();
+				if (vision[F])
+					m_dst->drawanim(pos[F], anim, 0, &owner);
+				for (uint32_t d = 1; d < 4; ++d) {
+					if
+						((vision[F] || vision[d]) &&
+						 isborder[d] &&
+						 (owner_number[d] == owner_number[F] || !owner_number[d]))
+					{
+						m_dst->drawanim(middle(pos[F], pos[d]), anim, 0, &owner);
+					}
+				}
+			}
+
+			if (1 < vision[F]) { // Render stuff that belongs to the node.
+				if (BaseImmovable * const imm = coords[F].field->get_immovable())
+					imm->draw(*m_egbase, *m_dst, coords[F], pos[F]);
+				for
+					(Bob * bob = coords[F].field->get_first_bob();
+					 bob;
+					 bob = bob->get_next_bob())
+					bob->draw(*m_egbase, *m_dst, pos[F]);
+			} else if (vision[F] == 1) {
+				Player::Field const & f_pl = m_player->fields()[map.get_index(coords[F], map.get_width())];
+				const Player * owner = owner_number[F] ? m_egbase->get_player(owner_number[F]) : 0;
+				if
+					(const Map_Object_Descr * const map_object_descr =
+						f_pl.map_object_descr[TCoords<>::None])
+				{
+					if
+						(const Player::Constructionsite_Information * const csinf =
+						 f_pl.constructionsite[TCoords<>::None])
+					{
+						// draw the partly finished constructionsite
+						uint32_t anim;
+						try {
+							anim = csinf->becomes->get_animation("build");
+						} catch (Map_Object_Descr::Animation_Nonexistent & e) {
+							try {
+								anim = csinf->becomes->get_animation("unoccupied");
+							} catch (Map_Object_Descr::Animation_Nonexistent) {
+								anim = csinf->becomes->get_animation("idle");
+							}
+						}
+						const AnimationGfx::Index nr_frames = g_gr->nr_frames(anim);
+						uint32_t cur_frame =
+							csinf->totaltime ? csinf->completedtime * nr_frames / csinf->totaltime : 0;
+						uint32_t tanim = cur_frame * FRAME_LENGTH;
+						uint32_t w, h;
+						g_gr->get_animation_size(anim, tanim, w, h);
+						uint32_t lines = h * csinf->completedtime * nr_frames;
+						if (csinf->totaltime)
+							lines /= csinf->totaltime;
+						assert(h * cur_frame <= lines);
+						lines -= h * cur_frame; //  This won't work if pictures have various sizes.
+
+						if (cur_frame) // not the first frame
+							// draw the prev frame from top to where next image will be drawing
+							m_dst->drawanimrect
+								(pos[F], anim, tanim - FRAME_LENGTH, owner, Rect(Point(0, 0), w, h - lines));
+						else if (csinf->was) {
+							// Is the first frame, but there was another building here before,
+							// get its last build picture and draw it instead.
+							uint32_t a;
+							try {
+								a = csinf->was->get_animation("unoccupied");
+							} catch (Map_Object_Descr::Animation_Nonexistent & e) {
+								a = csinf->was->get_animation("idle");
+							}
+							m_dst->drawanimrect
+								(pos[F], a, tanim - FRAME_LENGTH, owner, Rect(Point(0, 0), w, h - lines));
+						}
+						assert(lines <= h);
+						m_dst->drawanimrect(pos[F], anim, tanim, owner, Rect(Point(0, h - lines), w, lines));
+					} else if (upcast(const Building_Descr, building, map_object_descr)) {
+						// this is a building therefore we either draw unoccupied or idle animation
+						uint32_t pic;
+						try {
+							pic = building->get_animation("unoccupied");
+						} catch (Map_Object_Descr::Animation_Nonexistent & e) {
+							pic = building->get_animation("idle");
+						}
+						m_dst->drawanim(pos[F], pic, 0, owner);
+					} else if (const uint32_t pic = map_object_descr->main_animation()) {
+						m_dst->drawanim(pos[F], pic, 0, owner);
+					} else if (map_object_descr == &Widelands::g_flag_descr) {
+						m_dst->drawanim(pos[F], owner->flag_anim(), 0, owner);
+					}
+				}
+			}
+
+			{
+				// Render overlays on the node
+				Overlay_Manager::Overlay_Info overlay_info[MAX_OVERLAYS_PER_NODE];
+
+				const Overlay_Manager::Overlay_Info * const end =
+					overlay_info
+					+
+					map.overlay_manager().get_overlays(coords[F], overlay_info);
+
+				for
+					(const Overlay_Manager::Overlay_Info * it = overlay_info;
+					 it < end;
+					 ++it)
+					m_dst->blit(pos[F] - it->hotspot, it->pic);
+			}
+
+			{
+				// Render overlays on the R triangle
+				Overlay_Manager::Overlay_Info overlay_info[MAX_OVERLAYS_PER_TRIANGLE];
+				Overlay_Manager::Overlay_Info const * end =
+					overlay_info
+					+
+					map.overlay_manager().get_overlays
+							 	(TCoords<>(coords[F], TCoords<>::R), overlay_info);
+
+				Point tripos
+					((pos[F].x + pos[R].x + pos[BR].x) / 3,
+					 (pos[F].y + pos[R].y + pos[BR].y) / 3);
+
+				for
+					(Overlay_Manager::Overlay_Info const * it = overlay_info;
+					 it < end;
+					 ++it)
+					m_dst->blit(tripos - it->hotspot, it->pic);
+			}
+
+			{
+				// Render overlays on the D triangle
+				Overlay_Manager::Overlay_Info overlay_info[MAX_OVERLAYS_PER_TRIANGLE];
+				Overlay_Manager::Overlay_Info const * end =
+					overlay_info
+					+
+					map.overlay_manager().get_overlays
+							 	(TCoords<>(coords[F], TCoords<>::D), overlay_info);
+
+				Point tripos
+					((pos[F].x + pos[BL].x + pos[BR].x) / 3,
+					 (pos[F].y + pos[BL].y + pos[BR].y) / 3);
+
+				for
+					(Overlay_Manager::Overlay_Info const * it = overlay_info;
+					 it < end;
+					 ++it)
+					m_dst->blit(tripos - it->hotspot, it->pic);
+			}
+		}
+	}
+}
 
=== added file 'src/graphic/render/gamerenderer.h'
--- src/graphic/render/gamerenderer.h	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gamerenderer.h	2013-02-09 12:25:26 +0000
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2010-2013 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef WIDELANDS_GAMERENDERER_H
+#define WIDELANDS_GAMERENDERER_H
+
+#include "point.h"
+
+namespace Widelands {
+	struct Player;
+	struct Editor_Game_Base;
+};
+
+struct RenderTarget;
+
+/**
+ * This abstract base class renders the main game view into an
+ * arbitrary @ref RenderTarget.
+ *
+ * Specializations exist for SDL software rendering and for OpenGL rendering.
+ *
+ * Users of this class should keep instances alive for as long as possible,
+ * so that target-specific optimizations (such as caching data) can
+ * be effective.
+ */
+class GameRenderer {
+public:
+	GameRenderer();
+	virtual ~GameRenderer();
+
+	/**
+	 * Renders the map from a player's point of view into the
+	 * given drawing window.
+	 *
+	 * @param viewofs is the offset of the upper left corner of
+	 * the window into the map, in pixels.
+	 */
+	void rendermap
+		(RenderTarget & dst,
+		 Widelands::Editor_Game_Base const &       egbase,
+		 Widelands::Player           const &       player,
+		 Point                       const &       viewofs);
+
+	/**
+	 * Renders the map from an omniscient perspective.
+	 * This is used for spectators, players that see all, and in the editor.
+	 */
+	void rendermap
+		(RenderTarget & dst,
+		 Widelands::Editor_Game_Base const & egbase,
+		 Point                       const & viewofs);
+
+protected:
+	virtual void draw() = 0;
+
+	void draw_objects();
+
+	/**
+	 * The following variables, which are setup by @ref rendermap,
+	 * are only valid during rendering,
+	 * and should be treated as read-only by derived classes.
+	 */
+	/*@{*/
+	RenderTarget * m_dst;
+	Widelands::Editor_Game_Base const * m_egbase;
+	Widelands::Player const * m_player;
+
+	/// Translation from map pixel coordinates to @ref m_dst pixel coordinates
+	Point m_dst_offset;
+
+	int32_t m_minfx;
+	int32_t m_minfy;
+	int32_t m_maxfx;
+	int32_t m_maxfy;
+	/*@}*/
+
+private:
+	void draw_wrapper();
+};
+
+#endif //WIDELANDS_GAMEVIEW_H
 
=== added file 'src/graphic/render/gamerenderer_gl.cc'
--- src/graphic/render/gamerenderer_gl.cc	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gamerenderer_gl.cc	2013-02-09 12:25:26 +0000
@@ -0,0 +1,669 @@
+/*
+ * Copyright (C) 2011-2013 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifdef USE_OPENGL
+#include "gamerenderer_gl.h"
+
+#include "gl_surface.h"
+
+#include "logic/editor_game_base.h"
+#include "logic/player.h"
+
+#include "graphic/graphic.h"
+#include "graphic/rendertarget.h"
+#include "graphic/texture.h"
+
+#include "wui/mapviewpixelconstants.h"
+#include "wui/mapviewpixelfunctions.h"
+#include "wui/overlay_manager.h"
+
+#include <SDL_image.h>
+
+using namespace Widelands;
+
+static const uint32_t PatchSize = 4;
+
+GameRendererGL::GameRendererGL() :
+	m_patch_vertices_size(0),
+	m_patch_indices_size(0),
+	m_edge_vertices_size(0),
+	m_road_vertices_size(0)
+{
+}
+
+GameRendererGL::~GameRendererGL()
+{
+}
+
+const GLSurfaceTexture * GameRendererGL::get_dither_edge_texture(const Widelands::World & world)
+{
+	char fname[256];
+	snprintf(fname, sizeof(fname), "%s/pics/edge.png", world.basedir().c_str());
+	std::string cachename = std::string("gltex#") + fname;
+
+	const GLSurfaceTexture * edgetexture =
+		dynamic_cast<const GLSurfaceTexture *>(g_gr->imgcache().get(PicMod_Game, cachename));
+	if (!edgetexture) {
+		FileRead fr;
+		fr.fastOpen(*g_fs, fname);
+
+		SDL_Surface * sdlsurf = IMG_Load_RW(SDL_RWFromMem(fr.Data(0), fr.GetSize()), 1);
+		if (!sdlsurf)
+			throw wexception("%s", IMG_GetError());
+
+		edgetexture = new GLSurfaceTexture(sdlsurf, true);
+		g_gr->imgcache().insert(PicMod_Game, cachename, edgetexture);
+	}
+	return edgetexture;
+}
+
+uint32_t GameRendererGL::patch_index(const Coords & f) const
+{
+	uint32_t x = f.x - m_patch_size.x;
+	uint32_t y = f.y - m_patch_size.y;
+
+	assert(x < m_patch_size.w);
+	assert(y < m_patch_size.h);
+
+	uint32_t outerx = x / PatchSize;
+	uint32_t outery = y / PatchSize;
+	uint32_t innerx = x % PatchSize;
+	uint32_t innery = y % PatchSize;
+
+	return
+		(outery * (m_patch_size.w / PatchSize) + outerx) * (PatchSize * PatchSize) +
+		innery * PatchSize + innerx;
+}
+
+uint8_t GameRendererGL::field_brightness(const FCoords & coords) const
+{
+	uint32_t brightness;
+	brightness = 144 + coords.field->get_brightness();
+	brightness = (brightness * 255) / 160;
+	if (brightness > 255)
+		brightness = 255;
+
+	if (m_player && !m_player->see_all()) {
+		const Map & map = m_egbase->map();
+		const Player::Field & pf = m_player->fields()[Map::get_index(coords, map.get_width())];
+		if (pf.vision == 0) {
+			return 0;
+		} else if (pf.vision == 1) {
+			static const uint32_t DecayTime = 20000;
+			Duration time_ago = m_egbase->get_gametime() - pf.time_node_last_unseen;
+			if (time_ago < DecayTime)
+				brightness = (brightness * (2 * DecayTime - time_ago)) / (2 * DecayTime);
+			else
+				brightness = brightness / 2;
+		}
+	}
+
+	return brightness;
+}
+
+void GameRendererGL::draw()
+{
+	m_surface = dynamic_cast<GLSurface *>(m_dst->get_surface());
+	if (!m_surface)
+		return;
+	m_rect = m_dst->get_rect();
+	m_surface_offset = m_dst_offset + m_rect + m_dst->get_offset();
+
+	m_patch_size.x = m_minfx - 1;
+	m_patch_size.y = m_minfy;
+	m_patch_size.w = ((m_maxfx - m_minfx + 2 + PatchSize) / PatchSize) * PatchSize;
+	m_patch_size.h = ((m_maxfy - m_minfy + 1 + PatchSize) / PatchSize) * PatchSize;
+
+	glScissor
+		(m_rect.x, m_surface->get_h() - m_rect.y - m_rect.h,
+		 m_rect.w, m_rect.h);
+	glEnable(GL_SCISSOR_TEST);
+
+	prepare_terrain_base();
+	draw_terrain_base();
+	if (g_gr->caps().gl.multitexture && g_gr->caps().gl.max_tex_combined >= 2) {
+		prepare_terrain_dither();
+		draw_terrain_dither();
+	}
+	prepare_roads();
+	draw_roads();
+	draw_objects();
+
+	glDisable(GL_SCISSOR_TEST);
+}
+
+template<typename vertex>
+void GameRendererGL::compute_basevertex(const Coords & coords, vertex & vtx) const
+{
+	Map const & map = m_egbase->map();
+	Coords ncoords(coords);
+	map.normalize_coords(ncoords);
+	FCoords fcoords = map.get_fcoords(ncoords);
+	Point pix;
+	MapviewPixelFunctions::get_basepix(coords, pix.x, pix.y);
+	pix.y -= fcoords.field->get_height() * HEIGHT_FACTOR;
+	pix += m_surface_offset;
+	vtx.x = pix.x;
+	vtx.y = pix.y;
+	Point tex;
+	MapviewPixelFunctions::get_basepix(coords, tex.x, tex.y);
+	vtx.tcx = float(tex.x) / TEXTURE_WIDTH;
+	vtx.tcy = float(tex.y) / TEXTURE_HEIGHT;
+	uint8_t brightness = field_brightness(fcoords);
+	vtx.color[0] = vtx.color[1] = vtx.color[2] = brightness;
+	vtx.color[3] = 255;
+}
+
+void GameRendererGL::count_terrain_base(Terrain_Index ter)
+{
+	if (ter >= m_terrain_freq.size())
+		m_terrain_freq.resize(ter + 1);
+	m_terrain_freq[ter] += 1;
+}
+
+void GameRendererGL::add_terrain_base_triangle
+	(Terrain_Index ter, const Coords & p1, const Coords & p2, const Coords & p3)
+{
+	uint32_t index = m_patch_indices_indexs[ter];
+	m_patch_indices[index++] = patch_index(p1);
+	m_patch_indices[index++] = patch_index(p2);
+	m_patch_indices[index++] = patch_index(p3);
+	m_patch_indices_indexs[ter] = index;
+}
+
+void GameRendererGL::collect_terrain_base(bool onlyscan)
+{
+	Map const & map = m_egbase->map();
+
+	uint32_t index = 0;
+	for (uint32_t outery = 0; outery < m_patch_size.h / PatchSize; ++outery) {
+		for (uint32_t outerx = 0; outerx < m_patch_size.w / PatchSize; ++outerx) {
+			for (uint32_t innery = 0; innery < PatchSize; ++innery) {
+				for (uint32_t innerx = 0; innerx < PatchSize; ++innerx) {
+					Coords coords
+						(m_patch_size.x + outerx * PatchSize + innerx,
+						 m_patch_size.y + outery * PatchSize + innery);
+
+					if (onlyscan) {
+						assert(index == patch_index(coords));
+						compute_basevertex(coords, m_patch_vertices[index]);
+						++index;
+					}
+
+					if (coords.x >= m_minfx && coords.y >= m_minfy && coords.x <= m_maxfx && coords.y <= m_maxfy) {
+						Coords ncoords(coords);
+						map.normalize_coords(ncoords);
+						FCoords fcoords = map.get_fcoords(ncoords);
+						Terrain_Index ter_d = fcoords.field->get_terrains().d;
+						Terrain_Index ter_r = fcoords.field->get_terrains().r;
+
+						if (onlyscan) {
+							count_terrain_base(ter_d);
+							count_terrain_base(ter_r);
+						} else {
+							Coords brn(coords.x + (coords.y & 1), coords.y + 1);
+							Coords bln(brn.x - 1, brn.y);
+							Coords rn(coords.x + 1, coords.y);
+
+							add_terrain_base_triangle(ter_d, coords, bln, brn);
+							add_terrain_base_triangle(ter_r, coords, brn, rn);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void GameRendererGL::prepare_terrain_base()
+{
+	assert(sizeof(basevertex) == 32);
+
+	uint32_t reqsize = m_patch_size.w * m_patch_size.h;
+	if (reqsize > 0x10000)
+		throw wexception("Too many vertices; decrease screen resolution");
+
+	if (reqsize > m_patch_vertices_size) {
+		m_patch_vertices.reset(new basevertex[reqsize]);
+		m_patch_vertices_size = reqsize;
+	}
+
+	if (m_terrain_freq.size() < 16)
+		m_terrain_freq.resize(16);
+	m_terrain_freq.assign(m_terrain_freq.size(), 0);
+
+	collect_terrain_base(true);
+
+	m_terrain_freq_cum.resize(m_terrain_freq.size());
+	uint32_t nrtriangles = 0;
+	for (uint32_t idx = 0; idx < m_terrain_freq.size(); ++idx) {
+		m_terrain_freq_cum[idx] = nrtriangles;
+		nrtriangles += m_terrain_freq[idx];
+	}
+
+	if (3 * nrtriangles > m_patch_indices_size) {
+		m_patch_indices.reset(new uint16_t[3 * nrtriangles]);
+		m_patch_indices_size = 3 * nrtriangles;
+	}
+
+	m_patch_indices_indexs.resize(m_terrain_freq.size());
+	for (Terrain_Index ter = 0; ter < m_terrain_freq.size(); ++ter)
+		m_patch_indices_indexs[ter] = 3 * m_terrain_freq_cum[ter];
+
+	collect_terrain_base(false);
+
+	for (Terrain_Index ter = 0; ter < m_terrain_freq.size(); ++ter) {
+		assert(m_patch_indices_indexs[ter] == 3 * (m_terrain_freq_cum[ter] + m_terrain_freq[ter]));
+	}
+}
+
+void GameRendererGL::draw_terrain_base()
+{
+	Map const & map = m_egbase->map();
+	World const & world = map.world();
+
+	glMatrixMode(GL_TEXTURE);
+	glLoadIdentity();
+
+	glVertexPointer(2, GL_FLOAT, sizeof(basevertex), &m_patch_vertices[0].x);
+	glTexCoordPointer(2, GL_FLOAT, sizeof(basevertex), &m_patch_vertices[0].tcx);
+	glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(basevertex), &m_patch_vertices[0].color);
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	glEnableClientState(GL_COLOR_ARRAY);
+
+	glColor3f(1.0, 1.0, 1.0);
+	glDisable(GL_BLEND);
+
+	for (Terrain_Index ter = 0; ter < m_terrain_freq.size(); ++ter) {
+		if (!m_terrain_freq[ter])
+			continue;
+
+		const Texture & texture =
+				*g_gr->get_maptexture_data
+					(world.terrain_descr(ter).get_texture());
+		glBindTexture(GL_TEXTURE_2D, texture.getTexture());
+		glDrawRangeElements
+			(GL_TRIANGLES,
+			 0, m_patch_size.w * m_patch_size.h - 1,
+			 3 * m_terrain_freq[ter], GL_UNSIGNED_SHORT,
+			 &m_patch_indices[3 * m_terrain_freq_cum[ter]]);
+	}
+
+	glDisableClientState(GL_VERTEX_ARRAY);
+	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	glDisableClientState(GL_COLOR_ARRAY);
+}
+
+void GameRendererGL::add_terrain_dither_triangle
+	(bool onlyscan, Terrain_Index ter, const Coords & edge1, const Coords & edge2, const Coords & opposite)
+{
+	if (onlyscan) {
+		if (ter >= m_terrain_edge_freq.size())
+			m_terrain_edge_freq.resize(ter + 1);
+		m_terrain_edge_freq[ter] += 1;
+	} else {
+		static const float TyZero = 1.0 / TEXTURE_HEIGHT;
+		static const float TyOne = 1.0 - TyZero;
+
+		uint32_t index = m_terrain_edge_indexs[ter];
+		compute_basevertex(edge1, m_edge_vertices[index]);
+		m_edge_vertices[index].edgex = 0.0;
+		m_edge_vertices[index].edgey = TyZero;
+		++index;
+		compute_basevertex(edge2, m_edge_vertices[index]);
+		m_edge_vertices[index].edgex = 1.0;
+		m_edge_vertices[index].edgey = TyZero;
+		++index;
+		compute_basevertex(opposite, m_edge_vertices[index]);
+		m_edge_vertices[index].edgex = 0.5;
+		m_edge_vertices[index].edgey = TyOne;
+		++index;
+		m_terrain_edge_indexs[ter] = index;
+	}
+}
+
+void GameRendererGL::collect_terrain_dither(bool onlyscan)
+{
+	Map const & map = m_egbase->map();
+	World const & world = map.world();
+
+	for (int32_t fy = m_minfy; fy <= m_maxfy; ++fy) {
+		for (int32_t fx = m_minfx; fx <= m_maxfx; ++fx) {
+			Coords ncoords(fx, fy);
+			map.normalize_coords(ncoords);
+			FCoords fcoords = map.get_fcoords(ncoords);
+
+			Terrain_Index ter_d = fcoords.field->get_terrains().d;
+			Terrain_Index ter_r = fcoords.field->get_terrains().r;
+			Terrain_Index ter_u = map.tr_n(fcoords).field->get_terrains().d;
+			Terrain_Index ter_rr = map.r_n(fcoords).field->get_terrains().d;
+			Terrain_Index ter_l = map.l_n(fcoords).field->get_terrains().r;
+			Terrain_Index ter_dd = map.bl_n(fcoords).field->get_terrains().r;
+			int32_t lyr_d = world.get_ter(ter_d).dither_layer();
+			int32_t lyr_r = world.get_ter(ter_r).dither_layer();
+			int32_t lyr_u = world.get_ter(ter_u).dither_layer();
+			int32_t lyr_rr = world.get_ter(ter_rr).dither_layer();
+			int32_t lyr_l = world.get_ter(ter_l).dither_layer();
+			int32_t lyr_dd = world.get_ter(ter_dd).dither_layer();
+
+			Coords f(fx, fy);
+			Coords rn(fx + 1, fy);
+			Coords brn(fx + (fy & 1), fy + 1);
+			Coords bln(brn.x - 1, brn.y);
+
+			if (lyr_r > lyr_d) {
+				add_terrain_dither_triangle(onlyscan, ter_r, brn, f, bln);
+			} else if (ter_d != ter_r) {
+				add_terrain_dither_triangle(onlyscan, ter_d, f, brn, rn);
+			}
+			if ((lyr_u > lyr_r) || (lyr_u == lyr_r && ter_u != ter_r)) {
+				add_terrain_dither_triangle(onlyscan, ter_u, rn, f, brn);
+			}
+			if (lyr_rr > lyr_r) {
+				add_terrain_dither_triangle(onlyscan, ter_rr, brn, rn, f);
+			}
+			if ((lyr_l > lyr_d) || (lyr_l == lyr_d && ter_l != ter_d)) {
+				add_terrain_dither_triangle(onlyscan, ter_l, f, bln, brn);
+			}
+			if (lyr_dd > lyr_d) {
+				add_terrain_dither_triangle(onlyscan, ter_dd, bln, brn, f);
+			}
+		}
+	}
+}
+
+/*
+ * Schematic of triangle neighborhood:
+ *
+ *               *
+ *              / \
+ *             / u \
+ *         (f)/     \
+ *    *------*------* (r)
+ *     \  l / \  r / \
+ *      \  /   \  /   \
+ *       \/  d  \/ rr  \
+ *       *------*------* (br)
+ *        \ dd /
+ *         \  /
+ *          \/
+ *          *
+ */
+void GameRendererGL::prepare_terrain_dither()
+{
+	assert(sizeof(dithervertex) == 32);
+
+	if (m_terrain_edge_freq.size() < 16)
+		m_terrain_edge_freq.resize(16);
+	m_terrain_edge_freq.assign(m_terrain_edge_freq.size(), 0);
+
+	collect_terrain_dither(true);
+
+	uint32_t nrtriangles = 0;
+	m_terrain_edge_freq_cum.resize(m_terrain_edge_freq.size());
+	for (Terrain_Index ter = 0; ter < m_terrain_edge_freq.size(); ++ter) {
+		m_terrain_edge_freq_cum[ter] = nrtriangles;
+		nrtriangles += m_terrain_edge_freq[ter];
+	}
+
+	if (3 * nrtriangles > m_edge_vertices_size) {
+		m_edge_vertices.reset(new dithervertex[3 * nrtriangles]);
+		m_edge_vertices_size = 3 * nrtriangles;
+	}
+
+	m_terrain_edge_indexs.resize(m_terrain_edge_freq_cum.size());
+	for (Terrain_Index ter = 0; ter < m_terrain_edge_freq.size(); ++ter)
+		m_terrain_edge_indexs[ter] = 3 * m_terrain_edge_freq_cum[ter];
+
+	collect_terrain_dither(false);
+
+	for (Terrain_Index ter = 0; ter < m_terrain_edge_freq.size(); ++ter) {
+		assert(m_terrain_edge_indexs[ter] == 3 * (m_terrain_edge_freq_cum[ter] + m_terrain_edge_freq[ter]));
+	}
+}
+
+void GameRendererGL::draw_terrain_dither()
+{
+	Map const & map = m_egbase->map();
+	World const & world = map.world();
+
+	if (m_edge_vertices_size == 0)
+		return;
+
+	glVertexPointer(2, GL_FLOAT, sizeof(dithervertex), &m_edge_vertices[0].x);
+	glTexCoordPointer(2, GL_FLOAT, sizeof(dithervertex), &m_edge_vertices[0].tcx);
+	glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(dithervertex), &m_edge_vertices[0].color);
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	glEnableClientState(GL_COLOR_ARRAY);
+
+	glActiveTextureARB(GL_TEXTURE1_ARB);
+	glClientActiveTextureARB(GL_TEXTURE1_ARB);
+	glTexCoordPointer(2, GL_FLOAT, sizeof(dithervertex), &m_edge_vertices[0].edgex);
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	GLuint edge = get_dither_edge_texture(world)->get_gl_texture();
+	glBindTexture(GL_TEXTURE_2D, edge);
+	glEnable(GL_TEXTURE_2D);
+	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
+	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
+	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
+	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
+	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
+	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
+	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
+	glActiveTextureARB(GL_TEXTURE0_ARB);
+	glClientActiveTextureARB(GL_TEXTURE0_ARB);
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
+
+	for (Terrain_Index ter = 0; ter < m_terrain_freq.size(); ++ter) {
+		if (!m_terrain_edge_freq[ter])
+			continue;
+
+		const Texture & texture =
+				*g_gr->get_maptexture_data
+					(world.terrain_descr(ter).get_texture());
+		glBindTexture(GL_TEXTURE_2D, texture.getTexture());
+		glDrawArrays
+			(GL_TRIANGLES,
+			 3 * m_terrain_edge_freq_cum[ter], 3 * m_terrain_edge_freq[ter]);
+	}
+
+	glDisableClientState(GL_VERTEX_ARRAY);
+	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	glDisableClientState(GL_COLOR_ARRAY);
+	glActiveTextureARB(GL_TEXTURE1_ARB);
+	glClientActiveTextureARB(GL_TEXTURE1_ARB);
+	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	glDisable(GL_TEXTURE_2D);
+	glActiveTextureARB(GL_TEXTURE0_ARB);
+	glClientActiveTextureARB(GL_TEXTURE0_ARB);
+}
+
+uint8_t GameRendererGL::field_roads(const FCoords & coords) const
+{
+	if (m_player) {
+		const Map & map = m_egbase->map();
+		const Player::Field & pf = m_player->fields()[Map::get_index(coords, map.get_width())];
+		return pf.roads | map.get_overlay_manager().get_road_overlay(coords);
+	} else {
+		return coords.field->get_roads();
+	}
+}
+
+void GameRendererGL::prepare_roads()
+{
+	const Map & map = m_egbase->map();
+
+	m_road_freq[0] = 0;
+	m_road_freq[1] = 0;
+
+	for (int32_t fy = m_minfy; fy <= m_maxfy; ++fy) {
+		for (int32_t fx = m_minfx; fx <= m_maxfx; ++fx) {
+			Coords ncoords(fx, fy);
+			map.normalize_coords(ncoords);
+			FCoords fcoords = map.get_fcoords(ncoords);
+			uint8_t roads = field_roads(fcoords);
+
+			for (int dir = 0; dir < 3; ++dir) {
+				uint8_t road = (roads >> (2 * dir)) & Road_Mask;
+				if (road >= Road_Normal && road <= Road_Busy) {
+					++m_road_freq[road - Road_Normal];
+				}
+			}
+		}
+	}
+
+	uint32_t nrquads = m_road_freq[0] + m_road_freq[1];
+	if (4 * nrquads > m_road_vertices_size) {
+		m_road_vertices.reset(new basevertex[4 * nrquads]);
+		m_road_vertices_size = 4 * nrquads;
+	}
+
+	uint32_t indexs[2];
+	indexs[0] = 0;
+	indexs[1] = 4 * m_road_freq[0];
+
+	for (int32_t fy = m_minfy; fy <= m_maxfy; ++fy) {
+		for (int32_t fx = m_minfx; fx <= m_maxfx; ++fx) {
+			Coords ncoords(fx, fy);
+			map.normalize_coords(ncoords);
+			FCoords fcoords = map.get_fcoords(ncoords);
+			uint8_t roads = field_roads(fcoords);
+
+			uint8_t road = (roads >> Road_East) & Road_Mask;
+			if (road >= Road_Normal && road <= Road_Busy) {
+				uint32_t index = indexs[road - Road_Normal];
+				basevertex start, end;
+				compute_basevertex(Coords(fx, fy), start);
+				compute_basevertex(Coords(fx + 1, fy), end);
+				m_road_vertices[index] = start;
+				m_road_vertices[index].y -= 2;
+				m_road_vertices[index].tcy -= 2.0 / TEXTURE_HEIGHT;
+				++index;
+				m_road_vertices[index] = start;
+				m_road_vertices[index].y += 2;
+				m_road_vertices[index].tcy += 2.0 / TEXTURE_HEIGHT;
+				++index;
+				m_road_vertices[index] = end;
+				m_road_vertices[index].y += 2;
+				m_road_vertices[index].tcy += 2.0 / TEXTURE_HEIGHT;
+				++index;
+				m_road_vertices[index] = end;
+				m_road_vertices[index].y -= 2;
+				m_road_vertices[index].tcy -= 2.0 / TEXTURE_HEIGHT;
+				++index;
+				indexs[road - Road_Normal] = index;
+			}
+
+			road = (roads >> Road_SouthEast) & Road_Mask;
+			if (road >= Road_Normal && road <= Road_Busy) {
+				uint32_t index = indexs[road - Road_Normal];
+				basevertex start, end;
+				compute_basevertex(Coords(fx, fy), start);
+				compute_basevertex(Coords(fx + (fy & 1), fy + 1), end);
+				m_road_vertices[index] = start;
+				m_road_vertices[index].x += 3;
+				m_road_vertices[index].tcx += 3.0 / TEXTURE_HEIGHT;
+				++index;
+				m_road_vertices[index] = start;
+				m_road_vertices[index].x -= 3;
+				m_road_vertices[index].tcx -= 3.0 / TEXTURE_HEIGHT;
+				++index;
+				m_road_vertices[index] = end;
+				m_road_vertices[index].x -= 3;
+				m_road_vertices[index].tcx -= 3.0 / TEXTURE_HEIGHT;
+				++index;
+				m_road_vertices[index] = end;
+				m_road_vertices[index].x += 3;
+				m_road_vertices[index].tcx += 3.0 / TEXTURE_HEIGHT;
+				++index;
+				indexs[road - Road_Normal] = index;
+			}
+
+			road = (roads >> Road_SouthWest) & Road_Mask;
+			if (road >= Road_Normal && road <= Road_Busy) {
+				uint32_t index = indexs[road - Road_Normal];
+				basevertex start, end;
+				compute_basevertex(Coords(fx, fy), start);
+				compute_basevertex(Coords(fx + (fy & 1) - 1, fy + 1), end);
+				m_road_vertices[index] = start;
+				m_road_vertices[index].x += 3;
+				m_road_vertices[index].tcx += 3.0 / TEXTURE_HEIGHT;
+				++index;
+				m_road_vertices[index] = start;
+				m_road_vertices[index].x -= 3;
+				m_road_vertices[index].tcx -= 3.0 / TEXTURE_HEIGHT;
+				++index;
+				m_road_vertices[index] = end;
+				m_road_vertices[index].x -= 3;
+				m_road_vertices[index].tcx -= 3.0 / TEXTURE_HEIGHT;
+				++index;
+				m_road_vertices[index] = end;
+				m_road_vertices[index].x += 3;
+				m_road_vertices[index].tcx += 3.0 / TEXTURE_HEIGHT;
+				++index;
+				indexs[road - Road_Normal] = index;
+			}
+		}
+	}
+
+	assert(indexs[0] == 4 * m_road_freq[0]);
+	assert(indexs[1] == 4 * nrquads);
+}
+
+void GameRendererGL::draw_roads()
+{
+	if (!m_road_freq[0] && !m_road_freq[1])
+		return;
+
+	GLuint rt_normal =
+		dynamic_cast<GLSurfaceTexture const &>
+		(*g_gr->get_road_texture(Widelands::Road_Normal)).get_gl_texture();
+	GLuint rt_busy =
+		dynamic_cast<GLSurfaceTexture const &>
+		(*g_gr->get_road_texture(Widelands::Road_Busy)).get_gl_texture();
+
+	glVertexPointer(2, GL_FLOAT, sizeof(basevertex), &m_road_vertices[0].x);
+	glTexCoordPointer(2, GL_FLOAT, sizeof(basevertex), &m_road_vertices[0].tcx);
+	glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(basevertex), &m_road_vertices[0].color);
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	glEnableClientState(GL_COLOR_ARRAY);
+
+	glDisable(GL_BLEND);
+
+	if (m_road_freq[0]) {
+		glBindTexture(GL_TEXTURE_2D, rt_normal);
+		glDrawArrays(GL_QUADS, 0, 4 * m_road_freq[0]);
+	}
+
+	if (m_road_freq[1]) {
+		glBindTexture(GL_TEXTURE_2D, rt_busy);
+		glDrawArrays(GL_QUADS, 4 * m_road_freq[0], 4 * m_road_freq[1]);
+	}
+
+	glDisableClientState(GL_VERTEX_ARRAY);
+	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	glDisableClientState(GL_COLOR_ARRAY);
+}
+
+#endif // USE_OPENGL
 
=== added file 'src/graphic/render/gamerenderer_gl.h'
--- src/graphic/render/gamerenderer_gl.h	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gamerenderer_gl.h	2013-02-09 12:25:26 +0000
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2011-2013 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifdef USE_OPENGL
+#ifndef WIDELANDS_GAMERENDERER_GL_H
+#define WIDELANDS_GAMERENDERER_GL_H
+
+#include "gamerenderer.h"
+
+#include "logic/widelands.h"
+
+#include "rect.h"
+
+#include <vector>
+#include <boost/scoped_array.hpp>
+
+namespace Widelands {
+struct Coords;
+struct FCoords;
+struct World;
+}
+
+class GLSurface;
+class GLSurfaceTexture;
+
+/**
+ * OpenGL implementation of @ref GameRenderer.
+ */
+class GameRendererGL : public GameRenderer {
+public:
+	GameRendererGL();
+	virtual ~GameRendererGL();
+
+private:
+	struct basevertex {
+		float x;
+		float y;
+		float tcx;
+		float tcy;
+		uint8_t color[4];
+		uint32_t pad[3];
+	};
+
+	struct dithervertex {
+		float x;
+		float y;
+		float tcx;
+		float tcy;
+		float edgex;
+		float edgey;
+		uint8_t color[4];
+		uint32_t pad[1];
+	};
+
+	const GLSurfaceTexture * get_dither_edge_texture(const Widelands::World & world);
+
+	void draw();
+	void prepare_terrain_base();
+	void collect_terrain_base(bool onlyscan);
+	void count_terrain_base(Widelands::Terrain_Index ter);
+	void add_terrain_base_triangle
+		(Widelands::Terrain_Index ter,
+		 const Widelands::Coords & p1, const Widelands::Coords & p2, const Widelands::Coords & p3);
+	void draw_terrain_base();
+	void prepare_terrain_dither();
+	void collect_terrain_dither(bool onlyscan);
+	void add_terrain_dither_triangle
+		(bool onlyscan, Widelands::Terrain_Index ter,
+		 const Widelands::Coords & edge1, const Widelands::Coords & edge2,
+		 const Widelands::Coords & opposite);
+	void draw_terrain_dither();
+	void prepare_roads();
+	void draw_roads();
+
+	uint32_t patch_index(const Widelands::Coords & f) const;
+	uint8_t field_brightness(const Widelands::FCoords & coords) const;
+	uint8_t field_roads(const Widelands::FCoords & coords) const;
+	template<typename vertex>
+	void compute_basevertex(const Widelands::Coords & coords, vertex & vtx) const;
+
+	/**
+	 * The following variables are only valid during rendering.
+	 */
+	/*@{*/
+	GLSurface * m_surface;
+
+	/// Bounding rectangle inside the destination surface
+	Rect m_rect;
+
+	/// Translation from map pixel coordinates to surface pixel coordinates
+	/// (relative to the top-left corner of the surface, @b not relative
+	/// to the bounding rectangle)
+	Point m_surface_offset;
+
+	Rect m_patch_size;
+	boost::scoped_array<basevertex> m_patch_vertices;
+	uint32_t m_patch_vertices_size;
+	boost::scoped_array<uint16_t> m_patch_indices;
+	uint32_t m_patch_indices_size;
+	std::vector<uint32_t> m_patch_indices_indexs;
+	std::vector<uint32_t> m_terrain_freq;
+	std::vector<uint32_t> m_terrain_freq_cum;
+	boost::scoped_array<dithervertex> m_edge_vertices;
+	uint32_t m_edge_vertices_size;
+	std::vector<uint32_t> m_terrain_edge_freq;
+	std::vector<uint32_t> m_terrain_edge_freq_cum;
+	std::vector<uint32_t> m_terrain_edge_indexs;
+
+	uint32_t m_road_freq[2];
+	boost::scoped_array<basevertex> m_road_vertices;
+	uint32_t m_road_vertices_size;
+	/*@}*/
+};
+
+#endif // WIDELANDS_GAMERENDERER_GL_H
+#endif // USE_OPENGL
 
=== added file 'src/graphic/render/gamerenderer_sdl.cc'
--- src/graphic/render/gamerenderer_sdl.cc	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gamerenderer_sdl.cc	2013-02-09 12:25:26 +0000
@@ -0,0 +1,279 @@
+/*
+ * Copyright (C) 2010-2013 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#include "gamerenderer_sdl.h"
+
+#include "logic/field.h"
+#include "logic/map.h"
+#include "logic/player.h"
+
+#include "graphic/rendertarget.h"
+
+#include "wui/overlay_manager.h"
+
+#include "terrain_sdl.h"
+
+
+using namespace Widelands;
+
+///This is used by rendermap to calculate the brightness of the terrain.
+inline static Sint8 node_brightness
+	(Widelands::Time   const gametime,
+	 Widelands::Time   const last_seen,
+	 Widelands::Vision const vision,
+	 int8_t                  result)
+{
+	if      (vision == 0)
+		result = -128;
+	else if (vision == 1) {
+		assert(last_seen <= gametime);
+		Widelands::Duration const time_ago = gametime - last_seen;
+		result =
+			static_cast<Sint16>
+			(((static_cast<Sint16>(result) + 128) >> 1)
+			 *
+			 (1.0 + (time_ago < 45000 ? expf(-8.46126929e-5 * time_ago) : 0)))
+			-
+			128;
+	}
+
+	return result;
+}
+
+
+void GameRendererSDL::draw()
+{
+	draw_terrain();
+	draw_objects();
+}
+
+void GameRendererSDL::draw_terrain()
+{
+	if (m_player && !m_player->see_all())
+		m_dst->get_surface()->fill_rect(m_dst->get_rect(), RGBAColor(0, 0, 0, 255));
+
+	Map const & map = m_egbase->map();
+	World const & world = map.world();
+	uint32_t const mapwidth = map.get_width();
+
+#define get_terrain_texture(ter) \
+	(g_gr->get_maptexture_data(world.terrain_descr((ter)).get_texture()))
+
+	int32_t dx              = m_maxfx - m_minfx + 1;
+	int32_t dy              = m_maxfy - m_minfy + 1;
+	int32_t linear_fy       = m_minfy;
+	int32_t b_posy          = linear_fy * TRIANGLE_HEIGHT + m_dst_offset.y;
+
+	Widelands::Time const gametime = m_egbase->get_gametime();
+
+	while (dy--) {
+		const int32_t posy = b_posy;
+		b_posy += TRIANGLE_HEIGHT;
+		const int32_t linear_fx = m_minfx;
+		FCoords r(Coords(linear_fx, linear_fy));
+		FCoords br(Coords(linear_fx + (linear_fy & 1) - 1, linear_fy + 1));
+		int32_t r_posx =
+			r.x * TRIANGLE_WIDTH
+			+
+			(linear_fy & 1) * (TRIANGLE_WIDTH / 2)
+			+
+			m_dst_offset.x;
+		int32_t br_posx = r_posx - TRIANGLE_WIDTH / 2;
+
+		// Calculate safe (bounded) field coordinates and get field pointers
+		map.normalize_coords(r);
+		map.normalize_coords(br);
+		Map_Index  r_index = Map::get_index (r, mapwidth);
+		r.field = &map[r_index];
+		Map_Index br_index = Map::get_index(br, mapwidth);
+		br.field = &map[br_index];
+		FCoords tr;
+		map.get_tln(r, &tr);
+		Map_Index tr_index = tr.field - &map[0];
+
+		const Texture * f_r_texture;
+
+		if (m_player && !m_player->see_all()) {
+			const Player::Field & l_pf = m_player->fields()[Map::get_index(map.l_n(r), mapwidth)];
+			f_r_texture = get_terrain_texture(l_pf.terrains.r);
+		} else {
+			f_r_texture = get_terrain_texture(map.l_n(r).field->get_terrains().r);
+		}
+
+		uint32_t count = dx;
+
+		while (count--) {
+			const FCoords bl = br;
+			const FCoords f = r;
+			const int32_t f_posx = r_posx;
+			const int32_t bl_posx = br_posx;
+			Map_Index f_index = r_index;
+			Map_Index bl_index = br_index;
+			move_r(mapwidth, tr, tr_index);
+			move_r(mapwidth,  r,  r_index);
+			move_r(mapwidth, br, br_index);
+			r_posx  += TRIANGLE_WIDTH;
+			br_posx += TRIANGLE_WIDTH;
+
+			const Texture * l_r_texture = f_r_texture;
+			const Texture * f_d_texture;
+			const Texture * tr_d_texture;
+			uint8_t roads;
+			Sint8 f_brightness;
+			Sint8 r_brightness;
+			Sint8 bl_brightness;
+			Sint8 br_brightness;
+
+			if (m_player && !m_player->see_all()) {
+				const Player::Field & f_pf = m_player->fields()[f_index];
+				const Player::Field & r_pf = m_player->fields()[r_index];
+				const Player::Field & bl_pf = m_player->fields()[bl_index];
+				const Player::Field & br_pf = m_player->fields()[br_index];
+				const Player::Field & tr_pf = m_player->fields()[tr_index];
+
+				f_r_texture = get_terrain_texture(f_pf.terrains.r);
+				f_d_texture = get_terrain_texture(f_pf.terrains.d);
+				tr_d_texture = get_terrain_texture(tr_pf.terrains.d);
+
+				roads = f_pf.roads | map.overlay_manager().get_road_overlay(f);
+
+				f_brightness = node_brightness
+				 	(gametime, f_pf.time_node_last_unseen,
+				 	 f_pf.vision, f.field->get_brightness());
+				r_brightness = node_brightness
+				 	(gametime, r_pf.time_node_last_unseen,
+				 	 r_pf.vision, r.field->get_brightness());
+				bl_brightness = node_brightness
+				 	(gametime, bl_pf.time_node_last_unseen,
+				 	 bl_pf.vision, bl.field->get_brightness());
+				br_brightness = node_brightness
+				 	(gametime, br_pf.time_node_last_unseen,
+				 	 br_pf.vision, br.field->get_brightness());
+			} else {
+				f_r_texture = get_terrain_texture(f.field->get_terrains().r);
+				f_d_texture = get_terrain_texture(f.field->get_terrains().d);
+				tr_d_texture = get_terrain_texture(tr.field->get_terrains().d);
+
+				roads = f.field->get_roads();
+
+				f_brightness = f.field->get_brightness();
+				r_brightness = r.field->get_brightness();
+				bl_brightness = bl.field->get_brightness();
+				br_brightness = br.field->get_brightness();
+			}
+
+			Vertex f_vert
+				(f_posx, posy - f.field->get_height() * HEIGHT_FACTOR,
+				 f_brightness, 0, 0);
+			Vertex r_vert
+				(r_posx, posy - r.field->get_height() * HEIGHT_FACTOR,
+				 r_brightness, TRIANGLE_WIDTH, 0);
+			Vertex bl_vert
+				(bl_posx, b_posy - bl.field->get_height() * HEIGHT_FACTOR,
+				 bl_brightness, 0, 64);
+			Vertex br_vert
+				(br_posx, b_posy - br.field->get_height() * HEIGHT_FACTOR,
+				 br_brightness, TRIANGLE_WIDTH, 64);
+
+			if (linear_fy & 1) {
+				f_vert.tx += TRIANGLE_WIDTH / 2;
+				r_vert.tx += TRIANGLE_WIDTH / 2;
+			} else {
+				f_vert.tx += TRIANGLE_WIDTH;
+				r_vert.tx += TRIANGLE_WIDTH;
+				bl_vert.tx += TRIANGLE_WIDTH / 2;
+				br_vert.tx += TRIANGLE_WIDTH / 2;
+			}
+
+			draw_field //  Render ground
+				(*m_dst,
+				 f_vert, r_vert, bl_vert, br_vert,
+				 roads,
+				 *tr_d_texture, *l_r_texture, *f_d_texture, *f_r_texture);
+		}
+
+		++linear_fy;
+	}
+
+#undef get_terrain_texture
+}
+
+
+/**
+ * Draw ground textures and roads for the given parallelogram (two triangles)
+ * into the bitmap.
+ *
+ * Vertices:
+ *   - f_vert vertex of the field
+ *   - r_vert vertex right of the field
+ *   - bl_vert vertex bottom left of the field
+ *   - br_vert vertex bottom right of the field
+ *
+ * Textures:
+ *   - f_r_texture Terrain of the triangle right of the field
+ *   - f_d_texture Terrain of the triangle under of the field
+ *   - tr_d_texture Terrain of the triangle top of the right triangle ??
+ *   - l_r_texture Terrain of the triangle left of the down triangle ??
+ *
+ *             (tr_d)
+ *
+ *       (f) *------* (r)
+ *          / \  r /
+ *  (l_r)  /   \  /
+ *        /  d  \/
+ *  (bl) *------* (br)
+ */
+void GameRendererSDL::draw_field
+	(RenderTarget & dst,
+	 Vertex  const &  f_vert,
+	 Vertex  const &  r_vert,
+	 Vertex  const & bl_vert,
+	 Vertex  const & br_vert,
+	 uint8_t         roads,
+	 Texture const & tr_d_texture,
+	 Texture const &  l_r_texture,
+	 Texture const &  f_d_texture,
+	 Texture const &  f_r_texture)
+{
+	upcast(SDLSurface, sdlsurf, dst.get_surface());
+	if (sdlsurf)
+	{
+		sdlsurf->set_subwin(dst.get_rect());
+		switch (sdlsurf->format().BytesPerPixel) {
+		case 2:
+			draw_field_int<Uint16>
+				(*sdlsurf,
+				 f_vert, r_vert, bl_vert, br_vert,
+				 roads,
+				 tr_d_texture, l_r_texture, f_d_texture, f_r_texture);
+			break;
+		case 4:
+			draw_field_int<Uint32>
+				(*sdlsurf,
+				 f_vert, r_vert, bl_vert, br_vert,
+				 roads,
+				 tr_d_texture, l_r_texture, f_d_texture, f_r_texture);
+			break;
+		default:
+			assert(false);
+			break;
+		}
+		sdlsurf->unset_subwin();
+	}
+}
 
=== added file 'src/graphic/render/gamerenderer_sdl.h'
--- src/graphic/render/gamerenderer_sdl.h	1970-01-01 00:00:00 +0000
+++ src/graphic/render/gamerenderer_sdl.h	2013-02-09 12:25:26 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2010-2013 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef WIDELANDS_GAMERENDERER_SDL_H
+#define WIDELANDS_GAMERENDERER_SDL_H
+
+#include "gamerenderer.h"
+
+struct Texture;
+struct Vertex;
+
+/**
+ * Software-rendering implementation of @ref GameRenderer.
+ */
+class GameRendererSDL : public GameRenderer {
+protected:
+	void draw();
+
+private:
+	void draw_terrain();
+
+	/**
+	 * Helper function to draw two terrain triangles. This is called from the
+	 * rendermap() functions.
+	 */
+	void draw_field
+		(RenderTarget & dst,
+		 Vertex  const &  f_vert,
+		 Vertex  const &  r_vert,
+		 Vertex  const & bl_vert,
+		 Vertex  const & br_vert,
+		 uint8_t         roads,
+		 Texture const & tr_d_texture,
+		 Texture const &  l_r_texture,
+		 Texture const &  f_d_texture,
+		 Texture const &  f_r_texture);
+};
+
+#endif // WIDELANDS_GAMERENDERER_SDL_H
 
=== removed file 'src/graphic/render/gameview_opengl.cc'
--- src/graphic/render/gameview_opengl.cc	2012-09-21 21:36:07 +0000
+++ src/graphic/render/gameview_opengl.cc	1970-01-01 00:00:00 +0000
@@ -1,104 +0,0 @@
-/*
- * Copyright (C) 2011-2012 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.
- *
- */
-
-#ifdef USE_OPENGL
-
-#include "gameview_opengl.h"
-
-#include "constants.h"
-#include "economy/road.h"
-#include "graphic/graphic.h"
-#include "graphic/texture.h"
-
-#include "terrain_opengl.h"
-
-using namespace  Widelands;
-
-/**
- * Draw ground textures and roads for the given parallelogram (two triangles)
- * into the bitmap.
- *
- * Vertices:
- *   - f_vert vertex of the field
- *   - r_vert vertex right of the field
- *   - bl_vert vertex bottom left of the field
- *   - br_vert vertex bottom right of the field
- *
- * Textures:
- *   - f_r_texture Terrain of the triangle right of the field
- *   - f_d_texture Terrain of the triangle under of the field
- *   - tr_d_texture Terrain of the triangle top of the right triangle ??
- *   - l_r_texture Terrain of the triangle left of the down triangle ??
- *
- *             (tr_d)
- *
- *       (f) *------* (r)
- *          / \  r /
- *  (l_r)  /   \  /
- *        /  d  \/
- *  (bl) *------* (br)
- */
-void GameViewOpenGL::draw_field
-	(Rect          & subwin,
-	 Vertex  const &  f_vert,
-	 Vertex  const &  r_vert,
-	 Vertex  const & bl_vert,
-	 Vertex  const & br_vert,
-	 uint8_t         roads,
-	 Texture const & tr_d_texture,
-	 Texture const &  l_r_texture,
-	 Texture const &  f_d_texture,
-	 Texture const &  f_r_texture)
-{
-	// Draw triangle right (bottom) of the field
-	draw_field_opengl
-		(subwin, f_vert, br_vert, r_vert, f_r_texture, f_d_texture, tr_d_texture);
-	// Draw triangle bottom of the field
-	draw_field_opengl
-		(subwin, f_vert, bl_vert, br_vert, f_d_texture, l_r_texture, f_d_texture);
-
-	// Draw the roads
-	draw_roads_opengl(subwin, roads, f_vert, r_vert, bl_vert, br_vert);
-}
-
-void GameViewOpenGL::rendermap_init()
-{
-	glMatrixMode(GL_TEXTURE);
-	glLoadIdentity();
-	glScalef
-		(1.0f / static_cast<GLfloat>(TEXTURE_WIDTH),
-		 1.0f / static_cast<GLfloat>(TEXTURE_HEIGHT), 1);
-	glDisable(GL_BLEND);
-
-	// Use scissor test to clip the window. This takes coordinates in screen
-	// coordinates (y goes from bottom to top)
-	glScissor
-		(m_rect.x, g_gr->get_yres() - m_rect.y - m_rect.h,
-		 m_rect.w, m_rect.h);
-	glEnable(GL_SCISSOR_TEST);
-}
-
-void GameViewOpenGL::rendermap_deint()
-{
-	glDisable(GL_SCISSOR_TEST);
-	glMatrixMode(GL_TEXTURE);
-	glLoadIdentity();
-}
-
-#endif
 
=== removed file 'src/graphic/render/gameview_opengl.h'
--- src/graphic/render/gameview_opengl.h	2012-09-21 21:36:07 +0000
+++ src/graphic/render/gameview_opengl.h	1970-01-01 00:00:00 +0000
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2011 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.
- *
- */
-
-#ifdef USE_OPENGL
-#ifndef GAMEVIEW_OPENGL_H_
-#define GAMEVIEW_OPENGL_H_
-
-#include "gameview.h"
-
-class GameViewOpenGL : public GameView
-{
-public:
-	GameViewOpenGL(RenderTarget & rt):
-		GameView(rt) {}
-	~GameViewOpenGL() {}
-
-protected:
-	/**
-	 * Helper function to draw two terrain triangles. This is called from the
-	 * rendermap() functions.
-	 */
-	void draw_field
-		(Rect          & subwin,
-		 Vertex  const &  f_vert,
-		 Vertex  const &  r_vert,
-		 Vertex  const & bl_vert,
-		 Vertex  const & br_vert,
-		 uint8_t         roads,
-		 Texture const & tr_d_texture,
-		 Texture const &  l_r_texture,
-		 Texture const &  f_d_texture,
-		 Texture const &  f_r_texture);
-
-	void rendermap_init();
-	void rendermap_deint();
-};
-
-
-#endif /* GAMEVIEW_OPENGL_H_ */
-#endif /* USE_OPENGL */
 
=== removed file 'src/graphic/render/gameview_sdl.cc'
--- src/graphic/render/gameview_sdl.cc	2012-12-07 20:25:12 +0000
+++ src/graphic/render/gameview_sdl.cc	1970-01-01 00:00:00 +0000
@@ -1,105 +0,0 @@
-/*
- * Copyright (C) 2011-2012 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 "gameview_sdl.h"
-
-#include "upcast.h"
-
-#include "economy/road.h"
-#include "economy/flag.h"
-
-#include "wui/minimap.h"
-#include "wui/mapviewpixelconstants.h"
-
-#include "logic/field.h"
-#include "logic/map.h"
-#include "logic/player.h"
-
-#include "graphic/graphic.h"
-#include "graphic/rendertarget.h"
-#include "graphic/surface.h"
-#include "graphic/texture.h"
-
-#include "wui/overlay_manager.h"
-
-#include "terrain_sdl.h"
-
-
-/**
- * Draw ground textures and roads for the given parallelogram (two triangles)
- * into the bitmap.
- *
- * Vertices:
- *   - f_vert vertex of the field
- *   - r_vert vertex right of the field
- *   - bl_vert vertex bottom left of the field
- *   - br_vert vertex bottom right of the field
- *
- * Textures:
- *   - f_r_texture Terrain of the triangle right of the field
- *   - f_d_texture Terrain of the triangle under of the field
- *   - tr_d_texture Terrain of the triangle top of the right triangle ??
- *   - l_r_texture Terrain of the triangle left of the down triangle ??
- *
- *             (tr_d)
- *
- *       (f) *------* (r)
- *          / \  r /
- *  (l_r)  /   \  /
- *        /  d  \/
- *  (bl) *------* (br)
- */
-void GameViewSDL::draw_field
-	(Rect          & subwin,
-	 Vertex  const &  f_vert,
-	 Vertex  const &  r_vert,
-	 Vertex  const & bl_vert,
-	 Vertex  const & br_vert,
-	 uint8_t         roads,
-	 Texture const & tr_d_texture,
-	 Texture const &  l_r_texture,
-	 Texture const &  f_d_texture,
-	 Texture const &  f_r_texture)
-{
-	upcast(SDLSurface, sdlsurf, m_surface);
-	if (sdlsurf)
-	{
-		sdlsurf->set_subwin(subwin);
-		switch (sdlsurf->format().BytesPerPixel) {
-		case 2:
-			draw_field_int<Uint16>
-				(*sdlsurf,
-				 f_vert, r_vert, bl_vert, br_vert,
-				 roads,
-				 tr_d_texture, l_r_texture, f_d_texture, f_r_texture);
-			break;
-		case 4:
-			draw_field_int<Uint32>
-				(*sdlsurf,
-				 f_vert, r_vert, bl_vert, br_vert,
-				 roads,
-				 tr_d_texture, l_r_texture, f_d_texture, f_r_texture);
-			break;
-		default:
-			assert(false);
-			break;
-		}
-		sdlsurf->unset_subwin();
-	}
-}
 
=== removed file 'src/graphic/render/gameview_sdl.h'
--- src/graphic/render/gameview_sdl.h	2012-02-27 20:24:28 +0000
+++ src/graphic/render/gameview_sdl.h	1970-01-01 00:00:00 +0000
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2011-2012 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 GAMEVIEW_SDL_H_
-#define GAMEVIEW_SDL_H_
-
-#include "gameview.h"
-
-class GameViewSDL : public GameView
-{
-public:
-	GameViewSDL(RenderTarget & rt):
-		GameView(rt) {}
-	~GameViewSDL() {}
-
-protected:
-	/**
-	 * Helper function to draw two terrain triangles. This is called from the
-	 * rendermap() functions.
-	 */
-	void draw_field
-		(Rect          & subwin,
-		 Vertex  const &  f_vert,
-		 Vertex  const &  r_vert,
-		 Vertex  const & bl_vert,
-		 Vertex  const & br_vert,
-		 uint8_t         roads,
-		 Texture const & tr_d_texture,
-		 Texture const &  l_r_texture,
-		 Texture const &  f_d_texture,
-		 Texture const &  f_r_texture);
-};
-
-#endif /* GAMEVIEW_SDL_H_ */
 
=== modified file 'src/graphic/render/gl_surface_texture.cc'
--- src/graphic/render/gl_surface_texture.cc	2013-01-04 09:59:13 +0000
+++ src/graphic/render/gl_surface_texture.cc	2013-02-09 12:25:26 +0000
@@ -85,7 +85,7 @@
  *
  * \note Takes ownership of the given surface.
  */
-GLSurfaceTexture::GLSurfaceTexture(SDL_Surface * surface)
+GLSurfaceTexture::GLSurfaceTexture(SDL_Surface * surface, bool intensity)
 {
 	init(surface->w, surface->h);
 
@@ -166,7 +166,7 @@
 	SDL_LockSurface(surface);
 
 	glTexImage2D
-		(GL_TEXTURE_2D, 0, GL_RGBA, m_tex_w, m_tex_h, 0,
+		(GL_TEXTURE_2D, 0, intensity ? GL_INTENSITY : GL_RGBA, m_tex_w, m_tex_h, 0,
 		 pixels_format, GL_UNSIGNED_BYTE, surface->pixels);
 
 	SDL_UnlockSurface(surface);
 
=== modified file 'src/graphic/render/gl_surface_texture.h'
--- src/graphic/render/gl_surface_texture.h	2012-12-15 18:40:59 +0000
+++ src/graphic/render/gl_surface_texture.h	2013-02-09 12:25:26 +0000
@@ -30,7 +30,7 @@
 	static void Initialize();
 	static void Cleanup();
 
-	GLSurfaceTexture(SDL_Surface * surface);
+	GLSurfaceTexture(SDL_Surface * surface, bool intensity = false);
 	GLSurfaceTexture(int w, int h, bool alpha);
 	virtual ~GLSurfaceTexture();
 
 
=== renamed file 'src/graphic/render/gameview.cc' => 'src/graphic/render/minimaprenderer.cc'
--- src/graphic/render/gameview.cc	2012-12-14 20:09:35 +0000
+++ src/graphic/render/minimaprenderer.cc	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 by the Widelands Development Team
+ * Copyright (C) 2010-2013 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
@@ -17,7 +17,7 @@
  *
  */
 
-#include "gameview.h"
+#include "minimaprenderer.h"
 #include "upcast.h"
 
 #include "economy/road.h"
@@ -39,931 +39,7 @@
 
 #include "terrain_sdl.h"
 
-using Widelands::BaseImmovable;
-using Widelands::Coords;
-using Widelands::FCoords;
-using Widelands::Map;
-using Widelands::Map_Object_Descr;
-using Widelands::Player;
-using Widelands::TCoords;
-using namespace  Widelands;
-
-///This is used by rendermap to calculate the brightness of the terrain.
-inline static Sint8 node_brightness
-	(Widelands::Time   const gametime,
-	 Widelands::Time   const last_seen,
-	 Widelands::Vision const vision,
-	 int8_t                  result)
-{
-	if      (vision == 0)
-		result = -128;
-	else if (vision == 1) {
-		assert(last_seen <= gametime);
-		Widelands::Duration const time_ago = gametime - last_seen;
-		result =
-			static_cast<Sint16>
-			(((static_cast<Sint16>(result) + 128) >> 1)
-			 *
-			 (1.0 + (time_ago < 45000 ? expf(-8.46126929e-5 * time_ago) : 0)))
-			-
-			128;
-	}
-
-	return result;
-}
-
-
-#define RENDERMAP_INITIALIZATIONS                                             \
-   viewofs -= m_offset;                                                       \
-                                                                              \
-   Map                   const & map             = egbase.map();              \
-   Widelands::World      const & world           = map.world();               \
-   Overlay_Manager       const & overlay_manager = map.get_overlay_manager(); \
-   uint32_t const                mapwidth        = map.get_width();           \
-   int32_t minfx, minfy;                                                      \
-   int32_t maxfx, maxfy;                                                      \
-                                                                              \
-   /* hack to prevent negative numbers */                                     \
-   minfx = (viewofs.x + (TRIANGLE_WIDTH >> 1)) / TRIANGLE_WIDTH - 1;          \
-                                                                              \
-   minfy = viewofs.y / TRIANGLE_HEIGHT;                                       \
-   maxfx = (viewofs.x + (TRIANGLE_WIDTH >> 1) + m_rect.w) / TRIANGLE_WIDTH;   \
-   maxfy = (viewofs.y + m_rect.h) / TRIANGLE_HEIGHT;                          \
-   maxfx +=  1; /* because of big buildings */                                \
-   maxfy += 10; /* because of heights */                                      \
-                                                                              \
-   int32_t dx              = maxfx - minfx + 1;                               \
-   int32_t dy              = maxfy - minfy + 1;                               \
-   int32_t linear_fy       = minfy;                                           \
-   bool row_is_forward     = linear_fy & 1;                                   \
-   int32_t b_posy          = linear_fy * TRIANGLE_HEIGHT - viewofs.y;         \
-
-
-/**
- * Loop through fields row by row. For each field, draw ground textures, then
- * roads, then immovables, then bobs, then overlay stuff (build icons etc...)
- */
-void GameView::rendermap
-	(Widelands::Editor_Game_Base const &       egbase,
-	 Widelands::Player           const &       player,
-	 Point                                     viewofs)
-{
-	m_surface->fill_rect(m_rect, RGBAColor(0, 0, 0, 255));
-
-	if (player.see_all())
-		return rendermap(egbase, viewofs);
-
-	RENDERMAP_INITIALIZATIONS;
-
-	const Player::Field * const first_player_field = player.fields();
-	Widelands::Time const gametime = egbase.get_gametime();
-
-	rendermap_init();
-
-	while (dy--) {
-		const int32_t posy = b_posy;
-		b_posy += TRIANGLE_HEIGHT;
-		const int32_t linear_fx = minfx;
-		FCoords r(Coords(linear_fx, linear_fy));
-		FCoords br(Coords(linear_fx - not row_is_forward, linear_fy + 1));
-		int32_t r_posx =
-			r.x * TRIANGLE_WIDTH
-			+
-			row_is_forward * (TRIANGLE_WIDTH / 2)
-			-
-			viewofs.x;
-		int32_t br_posx = r_posx - TRIANGLE_WIDTH / 2;
-
-		// Calculate safe (bounded) field coordinates and get field pointers
-		map.normalize_coords(r);
-		map.normalize_coords(br);
-		Widelands::Map_Index  r_index = Map::get_index (r, mapwidth);
-		r.field = &map[r_index];
-		Widelands::Map_Index br_index = Map::get_index(br, mapwidth);
-		br.field = &map[br_index];
-		const Player::Field *  r_player_field = first_player_field +  r_index;
-		const Player::Field * br_player_field = first_player_field + br_index;
-		FCoords tr, f;
-		map.get_tln(r, &tr);
-		map.get_ln(r, &f);
-		Widelands::Map_Index tr_index = tr.field - &map[0];
-		const Texture * f_r_texture =
-			g_gr->get_maptexture_data
-				(world
-				 .terrain_descr(first_player_field[f.field - &map[0]].terrains.r)
-				 .get_texture());
-
-		uint32_t count = dx;
-
-		while (count--) {
-			const FCoords bl = br;
-			const Player::Field &  f_player_field =  *r_player_field;
-			const Player::Field & bl_player_field = *br_player_field;
-			f = r;
-			const int32_t f_posx = r_posx, bl_posx = br_posx;
-			const Texture & l_r_texture = *f_r_texture;
-			move_r(mapwidth, tr, tr_index);
-			move_r(mapwidth,  r,  r_index);
-			move_r(mapwidth, br, br_index);
-			r_player_field  = first_player_field +  r_index;
-			br_player_field = first_player_field + br_index;
-			r_posx  += TRIANGLE_WIDTH;
-			br_posx += TRIANGLE_WIDTH;
-			const Texture & tr_d_texture =
-				*g_gr->get_maptexture_data
-					(world.terrain_descr(first_player_field[tr_index].terrains.d).get_texture());
-			const Texture & f_d_texture =
-				*g_gr->get_maptexture_data(world.terrain_descr(f_player_field.terrains.d).get_texture());
-			f_r_texture =
-				g_gr->get_maptexture_data(world.terrain_descr(f_player_field.terrains.r).get_texture());
-
-			uint8_t const roads =
-				f_player_field.roads | overlay_manager.get_road_overlay(f);
-
-			Vertex f_vert
-				(f_posx, posy - f.field->get_height() * HEIGHT_FACTOR,
-				 node_brightness
-				 	(gametime, f_player_field.time_node_last_unseen,
-				 	 f_player_field.vision, f.field->get_brightness()),
-				 0, 0);
-			Vertex r_vert
-				(r_posx, posy - r.field->get_height() * HEIGHT_FACTOR,
-				 node_brightness
-				 	(gametime, r_player_field->time_node_last_unseen,
-				 	 r_player_field->vision, r.field->get_brightness()),
-				 TRIANGLE_WIDTH, 0);
-			Vertex bl_vert
-				(bl_posx, b_posy - bl.field->get_height() * HEIGHT_FACTOR,
-				 node_brightness
-				 	(gametime, bl_player_field.time_node_last_unseen,
-				 	 bl_player_field.vision, bl.field->get_brightness()),
-				 0, 64);
-			Vertex br_vert
-				(br_posx, b_posy - br.field->get_height() * HEIGHT_FACTOR,
-				 node_brightness
-				 	(gametime, br_player_field->time_node_last_unseen,
-				 	 br_player_field->vision, br.field->get_brightness()),
-				 TRIANGLE_WIDTH, 64);
-
-			if (row_is_forward) {
-				f_vert.tx += TRIANGLE_WIDTH / 2;
-				r_vert.tx += TRIANGLE_WIDTH / 2;
-			} else {
-				f_vert.tx += TRIANGLE_WIDTH;
-				r_vert.tx += TRIANGLE_WIDTH;
-				bl_vert.tx += TRIANGLE_WIDTH / 2;
-				br_vert.tx += TRIANGLE_WIDTH / 2;
-			}
-
-			draw_field //  Render ground
-				(m_rect,
-				 f_vert, r_vert, bl_vert, br_vert,
-				 roads,
-				 tr_d_texture, l_r_texture, f_d_texture, *f_r_texture);
-		}
-
-		++linear_fy;
-		row_is_forward = not row_is_forward;
-	}
-
-	{
-		const int32_t dx2        = maxfx - minfx + 1;
-		int32_t dy2              = maxfy - minfy + 1;
-		int32_t linear_fy2       = minfy;
-		bool row_is_forward2     = linear_fy2 & 1;
-		int32_t b_posy2          = linear_fy2 * TRIANGLE_HEIGHT - viewofs.y - m_offset.y;
-
-		while (dy2--) {
-			const int32_t posy = b_posy2;
-			b_posy2 += TRIANGLE_HEIGHT;
-
-			{ //  Draw things on the node.
-				const int32_t linear_fx = minfx;
-				FCoords r (Coords(linear_fx, linear_fy2));
-				FCoords br(Coords(linear_fx - not row_is_forward2, linear_fy2 + 1));
-
-				//  Calculate safe (bounded) field coordinates and get field pointers.
-				map.normalize_coords(r);
-				map.normalize_coords(br);
-				Widelands::Map_Index  r_index = Map::get_index (r, mapwidth);
-				r.field = &map[r_index];
-				Widelands::Map_Index br_index = Map::get_index(br, mapwidth);
-				br.field = &map[br_index];
-				FCoords tr, f;
-				map.get_tln(r, &tr);
-				map.get_ln(r, &f);
-				bool r_is_border;
-				uint8_t f_owner_number = f.field->get_owned_by();   //  do not use if f_vision < 1 -> PPOV
-				uint8_t r_owner_number;
-				r_is_border = r.field->is_border();                 //  do not use if f_vision < 1 -> PPOV
-				r_owner_number = r.field->get_owned_by();           //  do not use if f_vision < 1 -> PPOV
-				uint8_t br_owner_number = br.field->get_owned_by(); //  do not use if f_vision < 1 -> PPOV
-				Player::Field const * r_player_field = first_player_field + r_index;
-				const Player::Field * br_player_field = first_player_field + br_index;
-				Widelands::Vision  r_vision =  r_player_field->vision;
-				Widelands::Vision br_vision = br_player_field->vision;
-				Point r_pos
-					(linear_fx * TRIANGLE_WIDTH
-					 +
-					 row_is_forward2 * (TRIANGLE_WIDTH / 2)
-					 -
-					 viewofs.x - m_offset.x,
-					 posy - r.field->get_height() * HEIGHT_FACTOR);
-				Point br_pos
-					(r_pos.x - TRIANGLE_WIDTH / 2,
-					 b_posy2 - br.field->get_height() * HEIGHT_FACTOR);
-
-				int32_t count = dx2;
-
-				while (count--) {
-					f = r;
-					const Player::Field & f_player_field = *r_player_field;
-					move_r(mapwidth, tr);
-					move_r(mapwidth,  r,  r_index);
-					move_r(mapwidth, br, br_index);
-					r_player_field  = first_player_field +  r_index;
-					br_player_field = first_player_field + br_index;
-
-					//  do not use if f_vision < 1 -> PPOV
-					const uint8_t tr_owner_number = tr.field->get_owned_by();
-
-					const bool f_is_border = r_is_border;
-					const uint8_t l_owner_number = f_owner_number;
-					const uint8_t bl_owner_number = br_owner_number;
-					f_owner_number = r_owner_number;
-					r_is_border = r.field->is_border();         //  do not use if f_vision < 1 -> PPOV
-					r_owner_number = r.field->get_owned_by();   //  do not use if f_vision < 1 -> PPOV
-					br_owner_number = br.field->get_owned_by(); //  do not use if f_vision < 1 -> PPOV
-					Widelands::Vision const  f_vision =  r_vision;
-					Widelands::Vision const bl_vision = br_vision;
-					r_vision  = player.vision (r_index);
-					br_vision = player.vision(br_index);
-					const Point f_pos = r_pos, bl_pos = br_pos;
-					r_pos = Point(r_pos.x + TRIANGLE_WIDTH, posy - r.field->get_height() * HEIGHT_FACTOR);
-					br_pos = Point(br_pos.x + TRIANGLE_WIDTH, b_posy2 - br.field->get_height() * HEIGHT_FACTOR);
-
-					if (1 < f_vision) { // Render stuff that belongs to the node.
-						//  Render border markes on and halfway between border nodes.
-						if (f_is_border) {
-							const Player & owner = egbase.player(f_owner_number);
-							uint32_t const anim = owner.frontier_anim();
-							drawanim(f_pos, anim, 0, &owner);
-							if
-								((f_vision | r_vision)
-								 and
-								 r_owner_number == f_owner_number
-								 and
-								 ((tr_owner_number == f_owner_number)
-								 xor
-								 (br_owner_number == f_owner_number)))
-								drawanim(middle(f_pos, r_pos), anim, 0, &owner);
-							if
-								((f_vision | bl_vision)
-								 and
-								 bl_owner_number == f_owner_number
-								 and
-								 ((l_owner_number == f_owner_number)
-								 xor
-								 (br_owner_number == f_owner_number)))
-								drawanim(middle(f_pos, bl_pos), anim, 0, &owner);
-							if
-								((f_vision | br_vision)
-								 and
-								 br_owner_number == f_owner_number
-								 and
-								 ((r_owner_number == f_owner_number)
-								 xor
-								 (bl_owner_number == f_owner_number)))
-								drawanim(middle(f_pos, br_pos), anim, 0, &owner);
-						}
-
-
-						// Render bobs
-						// TODO - rendering order?
-						//  This must be defined somehow. Some bobs have a higher
-						//  priority than others. Maybe this priority is a moving
-						//  versus non-moving bobs thing? draw_ground implies that
-						//  this doesn't render map objects. Are there any overdraw
-						//  issues with the current rendering order?
-
-						// Draw Map_Objects hooked to this field
-						if (BaseImmovable * const imm = f.field->get_immovable())
-							imm->draw(egbase, *this, f, f_pos);
-						for
-							(Widelands::Bob * bob = f.field->get_first_bob();
-							 bob;
-							 bob = bob->get_next_bob())
-							bob->draw(egbase, *this, f_pos);
-
-						//  Render overlays on nodes.
-						Overlay_Manager::Overlay_Info
-							overlay_info[MAX_OVERLAYS_PER_NODE];
-
-						const Overlay_Manager::Overlay_Info * const end =
-							overlay_info
-							+
-							overlay_manager.get_overlays(f, overlay_info);
-
-						for
-							(const Overlay_Manager::Overlay_Info * it = overlay_info;
-							 it < end;
-							 ++it)
-							blit(f_pos - it->hotspot, it->pic);
-					} else if (f_vision == 1) {
-						const Player * owner = f_player_field.owner ? egbase.get_player(f_player_field.owner) : 0;
-						if (owner) {
-							// Draw borders as they stood the last time we saw them
-							uint32_t const anim = owner->frontier_anim();
-							if (f_player_field.border)
-								drawanim(f_pos, anim, 0, owner);
-							if (f_player_field.border_r)
-								drawanim(middle(f_pos,  r_pos), anim, 0, owner);
-							if (f_player_field.border_br)
-								drawanim(middle(f_pos, bl_pos), anim, 0, owner);
-							if (f_player_field.border_bl)
-								drawanim(middle(f_pos, br_pos), anim, 0, owner);
-						}
-						if
-							(const Map_Object_Descr * const map_object_descr =
-							 f_player_field.map_object_descr[TCoords<>::None])
-						{
-							if
-								(const Player::Constructionsite_Information * const csinf =
-								 f_player_field.constructionsite[TCoords<>::None])
-							{
-								// draw the partly finished constructionsite
-								uint32_t anim;
-								try {
-									anim = csinf->becomes->get_animation("build");
-								} catch (Map_Object_Descr::Animation_Nonexistent & e) {
-									try {
-										anim = csinf->becomes->get_animation("unoccupied");
-									} catch (Map_Object_Descr::Animation_Nonexistent) {
-										anim = csinf->becomes->get_animation("idle");
-									}
-								}
-								const AnimationGfx::Index nr_frames = g_gr->nr_frames(anim);
-								uint32_t cur_frame =
-									csinf->totaltime ? csinf->completedtime * nr_frames / csinf->totaltime : 0;
-								uint32_t tanim = cur_frame * FRAME_LENGTH;
-								uint32_t w, h;
-								g_gr->get_animation_size(anim, tanim, w, h);
-								uint32_t lines = h * csinf->completedtime * nr_frames;
-								if (csinf->totaltime)
-									lines /= csinf->totaltime;
-								assert(h * cur_frame <= lines);
-								lines -= h * cur_frame; //  This won't work if pictures have various sizes.
-
-								if (cur_frame) // not the first frame
-									// draw the prev frame from top to where next image will be drawing
-									drawanimrect
-										(f_pos, anim, tanim - FRAME_LENGTH, owner, Rect(Point(0, 0), w, h - lines));
-								else if (csinf->was) {
-									// Is the first frame, but there was another building here before,
-									// get its last build picture and draw it instead.
-									uint32_t a;
-									try {
-										a = csinf->was->get_animation("unoccupied");
-									} catch (Map_Object_Descr::Animation_Nonexistent & e) {
-										a = csinf->was->get_animation("idle");
-									}
-									drawanimrect
-										(f_pos, a, tanim - FRAME_LENGTH, owner, Rect(Point(0, 0), w, h - lines));
-								}
-								assert(lines <= h);
-								drawanimrect(f_pos, anim, tanim, owner, Rect(Point(0, h - lines), w, lines));
-							} else if (upcast(const Building_Descr, building, map_object_descr)) {
-								// this is a building therefore we either draw unoccupied or idle animation
-								uint32_t pic;
-								try {
-									pic = building->get_animation("unoccupied");
-								} catch (Map_Object_Descr::Animation_Nonexistent & e) {
-									pic = building->get_animation("idle");
-								}
-								drawanim(f_pos, pic, 0, owner);
-							} else if (const uint32_t pic = map_object_descr->main_animation()) {
-								drawanim(f_pos, pic, 0, owner);
-							} else if (map_object_descr == &Widelands::g_flag_descr) {
-								drawanim(f_pos, owner->flag_anim(), 0, owner);
-							}
-						}
-					}
-				}
-			}
-
-			if (false) { //  Draw things on the R-triangle (nothing to draw yet).
-				const int32_t linear_fx = minfx;
-				FCoords r(Coords(linear_fx, linear_fy2));
-				FCoords b(Coords(linear_fx - not row_is_forward2, linear_fy2 + 1));
-				int32_t posx =
-					(linear_fx - 1) * TRIANGLE_WIDTH
-					+
-					(row_is_forward2 + 1) * (TRIANGLE_WIDTH / 2)
-					-
-					viewofs.x;
-
-				//  Calculate safe (bounded) field coordinates.
-				map.normalize_coords(r);
-				map.normalize_coords(b);
-
-				//  Get field pointers.
-				r.field = &map[Map::get_index(r, mapwidth)];
-				b.field = &map[Map::get_index(b, mapwidth)];
-
-				int32_t count = dx2;
-
-				//  One less iteration than for nodes and D-triangles.
-				while (--count) {
-					const FCoords f = r;
-					map.get_rn(r, &r);
-					map.get_rn(b, &b);
-					posx += TRIANGLE_WIDTH;
-
-					//  FIXME Implement visibility rules for objects on triangles
-					//  FIXME when they are used in the game. The only things that
-					//  FIXME are drawn on triangles now (except the ground) are
-					//  FIXME overlays for the editor terrain tool, and the editor
-					//  FIXME does not need visibility rules.
-					{ //  FIXME Visibility check here.
-						Overlay_Manager::Overlay_Info overlay_info
-							[MAX_OVERLAYS_PER_TRIANGLE];
-						const Overlay_Manager::Overlay_Info & overlay_info_end = *
-							(overlay_info
-							 +
-							 overlay_manager.get_overlays
-							 	(TCoords<>(f, TCoords<>::R), overlay_info));
-
-						for
-							(const Overlay_Manager::Overlay_Info * it = overlay_info;
-							 it < &overlay_info_end;
-							 ++it)
-							blit
-								(Point
-								 	(posx,
-								 	 posy
-								 	 +
-								 	 (TRIANGLE_HEIGHT
-								 	  -
-								 	  (f.field->get_height()
-								 	   +
-								 	   r.field->get_height()
-								 	   +
-								 	   b.field->get_height())
-								 	  *
-								 	  HEIGHT_FACTOR)
-								 	 /
-								 	 3)
-								 -
-								 it->hotspot,
-								 it->pic);
-					}
-				}
-			}
-
-			if (false) { //  Draw things on the D-triangle (nothing to draw yet).
-				const int32_t linear_fx = minfx;
-				FCoords f(Coords(linear_fx - 1, linear_fy2));
-				FCoords br
-					(Coords(linear_fx - not row_is_forward2, linear_fy2 + 1));
-				int32_t posx =
-					(linear_fx - 1) * TRIANGLE_WIDTH
-					+
-					row_is_forward2 * (TRIANGLE_WIDTH / 2)
-					-
-					viewofs.x;
-
-				//  Calculate safe (bounded) field coordinates.
-				map.normalize_coords(f);
-				map.normalize_coords(br);
-
-				//  Get field pointers.
-				f.field  = &map[Map::get_index(f,  mapwidth)];
-				br.field = &map[Map::get_index(br, mapwidth)];
-
-				int32_t count = dx2;
-
-				while (count--) {
-					const FCoords bl = br;
-					map.get_rn(f, &f);
-					map.get_rn(br, &br);
-					posx += TRIANGLE_WIDTH;
-
-					{ //  FIXME Visibility check here.
-						Overlay_Manager::Overlay_Info overlay_info
-							[MAX_OVERLAYS_PER_TRIANGLE];
-						Overlay_Manager::Overlay_Info const * const overlay_info_end
-							=
-							overlay_info
-							+
-							overlay_manager.get_overlays
-								(TCoords<>(f, TCoords<>::D), overlay_info);
-
-						for
-							(const Overlay_Manager::Overlay_Info * it = overlay_info;
-							 it < overlay_info_end;
-							 ++it)
-							blit
-								(Point
-								 	(posx,
-								 	 posy
-								 	 +
-								 	 ((TRIANGLE_HEIGHT * 2)
-								 	  -
-								 	  (f.field->get_height()
-								 	   +
-								 	   bl.field->get_height()
-								 	   +
-								 	   br.field->get_height())
-								 	  *
-								 	  HEIGHT_FACTOR)
-								 	 /
-								 	 3)
-								 -
-								 it->hotspot,
-								 it->pic);
-					}
-				}
-			}
-
-			++linear_fy2;
-			row_is_forward2 = not row_is_forward2;
-		}
-	}
-
-	rendermap_deint();
-
-	g_gr->reset_texture_animation_reminder();
-}
-
-void GameView::rendermap
-	(Widelands::Editor_Game_Base const &       egbase,
-	 Point                                     viewofs)
-{
-	RENDERMAP_INITIALIZATIONS;
-
-	rendermap_init();
-
-	while (dy--) {
-		const int32_t posy = b_posy;
-		b_posy += TRIANGLE_HEIGHT;
-		const int32_t linear_fx = minfx;
-		FCoords r(Coords(linear_fx, linear_fy));
-		FCoords br(Coords(linear_fx - not row_is_forward, linear_fy + 1));
-		int32_t r_posx =
-			r.x * TRIANGLE_WIDTH
-			+
-			row_is_forward * (TRIANGLE_WIDTH / 2)
-			-
-			viewofs.x;
-		int32_t br_posx = r_posx - TRIANGLE_WIDTH / 2;
-
-		// Calculate safe (bounded) field coordinates and get field pointers
-		map.normalize_coords(r);
-		map.normalize_coords(br);
-		Widelands::Map_Index  r_index = Map::get_index (r, mapwidth);
-		r.field = &map[r_index];
-		Widelands::Map_Index br_index = Map::get_index(br, mapwidth);
-		br.field = &map[br_index];
-		FCoords tr, f;
-		map.get_tln(r, &tr);
-		map.get_ln(r, &f);
-		const Texture * f_r_texture =
-			g_gr->get_maptexture_data
-				(world.terrain_descr(f.field->terrain_r()).get_texture());
-
-		uint32_t count = dx;
-
-		while (count--) {
-			const FCoords bl = br;
-			f = r;
-			const int32_t f_posx = r_posx, bl_posx = br_posx;
-			const Texture & l_r_texture = *f_r_texture;
-			move_r(mapwidth, tr);
-			move_r(mapwidth,  r,  r_index);
-			move_r(mapwidth, br, br_index);
-			r_posx  += TRIANGLE_WIDTH;
-			br_posx += TRIANGLE_WIDTH;
-			const Texture & tr_d_texture =
-				*g_gr->get_maptexture_data
-					(world.terrain_descr(tr.field->terrain_d()).get_texture());
-			const Texture & f_d_texture =
-				*g_gr->get_maptexture_data
-					(world.terrain_descr(f.field->terrain_d()).get_texture());
-			f_r_texture =
-				g_gr->get_maptexture_data
-					(world.terrain_descr(f.field->terrain_r()).get_texture());
-
-			const uint8_t roads =
-				f.field->get_roads() | overlay_manager.get_road_overlay(f);
-
-			Vertex f_vert
-				(f_posx, posy - f.field->get_height() * HEIGHT_FACTOR,
-				 f.field->get_brightness(),
-				 0, 0);
-			Vertex r_vert
-				(r_posx, posy - r.field->get_height() * HEIGHT_FACTOR,
-				 r.field->get_brightness(),
-				 TRIANGLE_WIDTH, 0);
-			Vertex bl_vert
-				(bl_posx, b_posy - bl.field->get_height() * HEIGHT_FACTOR,
-				 bl.field->get_brightness(),
-				 0, 64);
-			Vertex br_vert
-				(br_posx, b_posy - br.field->get_height() * HEIGHT_FACTOR,
-				 br.field->get_brightness(),
-				 TRIANGLE_WIDTH, 64);
-
-			if (row_is_forward) {
-				f_vert.tx += TRIANGLE_WIDTH / 2;
-				r_vert.tx += TRIANGLE_WIDTH / 2;
-			} else {
-				bl_vert.tx -= TRIANGLE_WIDTH / 2;
-				br_vert.tx -= TRIANGLE_WIDTH / 2;
-			}
-
-			draw_field //  Render ground
-				(m_rect,
-				 f_vert, r_vert, bl_vert, br_vert,
-				 roads,
-				 tr_d_texture, l_r_texture, f_d_texture, *f_r_texture);
-		}
-
-		++linear_fy;
-		row_is_forward = not row_is_forward;
-	}
-
-	{
-		const int32_t dx2 = maxfx - minfx + 1;
-		int32_t dy2 = maxfy - minfy + 1;
-		int32_t linear_fy2 = minfy;
-		bool row_is_forward2 = linear_fy2 & 1;
-		int32_t b_posy2 = linear_fy2 * TRIANGLE_HEIGHT - viewofs.y;
-
-		while (dy2--) {
-			const int32_t posy = b_posy2;
-			b_posy2 += TRIANGLE_HEIGHT;
-
-			{ //  Draw things on the node.
-				const int32_t linear_fx = minfx;
-				FCoords r(Coords(linear_fx, linear_fy2));
-				FCoords br
-					(Coords(linear_fx - not row_is_forward2, linear_fy2 + 1));
-
-				//  Calculate safe (bounded) field coordinates and get field
-				//  pointers.
-				map.normalize_coords(r);
-				map.normalize_coords(br);
-				Widelands::Map_Index  r_index = Map::get_index (r, mapwidth);
-				r.field = &map[r_index];
-				Widelands::Map_Index br_index = Map::get_index(br, mapwidth);
-				br.field = &map[br_index];
-				FCoords tr, f;
-				map.get_tln(r, &tr);
-				map.get_ln(r, &f);
-				bool r_is_border;
-				uint8_t f_owner_number = f.field->get_owned_by();
-				uint8_t r_owner_number;
-				r_is_border = r.field->is_border();
-				r_owner_number = r.field->get_owned_by();
-				uint8_t br_owner_number = br.field->get_owned_by();
-				Point r_pos
-					(linear_fx * TRIANGLE_WIDTH
-					 +
-					 row_is_forward2 * (TRIANGLE_WIDTH / 2)
-					 -
-					 viewofs.x,
-					 posy - r.field->get_height() * HEIGHT_FACTOR);
-				Point br_pos
-					(r_pos.x - TRIANGLE_WIDTH / 2,
-					 b_posy2 - br.field->get_height() * HEIGHT_FACTOR);
-
-				int32_t count = dx2;
-
-				while (count--) {
-					f = r;
-					move_r(mapwidth, tr);
-					move_r(mapwidth,  r,  r_index);
-					move_r(mapwidth, br, br_index);
-					const uint8_t tr_owner_number = tr.field->get_owned_by();
-					const bool f_is_border = r_is_border;
-					const uint8_t l_owner_number = f_owner_number;
-					const uint8_t bl_owner_number = br_owner_number;
-					f_owner_number = r_owner_number;
-					r_is_border = r.field->is_border();
-					r_owner_number = r.field->get_owned_by();
-					br_owner_number = br.field->get_owned_by();
-					const Point f_pos = r_pos, bl_pos = br_pos;
-					r_pos = Point
-						(r_pos.x + TRIANGLE_WIDTH,
-						 posy - r.field->get_height() * HEIGHT_FACTOR);
-					br_pos = Point
-						(br_pos.x + TRIANGLE_WIDTH,
-						 b_posy2 - br.field->get_height() * HEIGHT_FACTOR);
-
-					//  Render border markes on and halfway between border nodes.
-					if (f_is_border) {
-						const Player & owner = egbase.player(f_owner_number);
-						uint32_t const anim = owner.frontier_anim();
-						drawanim(f_pos, anim, 0, &owner);
-						if
-							(r_owner_number == f_owner_number
-							 and
-							 ((tr_owner_number == f_owner_number)
-							  xor
-							  (br_owner_number == f_owner_number)))
-							drawanim(middle(f_pos, r_pos), anim, 0, &owner);
-						if
-							(bl_owner_number == f_owner_number
-							 and
-							 ((l_owner_number == f_owner_number)
-							  xor
-							  (br_owner_number == f_owner_number)))
-							drawanim(middle(f_pos, bl_pos), anim, 0, &owner);
-						if
-							(br_owner_number == f_owner_number
-							 and
-							 ((r_owner_number == f_owner_number)
-							  xor
-							  (bl_owner_number == f_owner_number)))
-							drawanim(middle(f_pos, br_pos), anim, 0, &owner);
-					}
-
-					{ // Render stuff that belongs to the node.
-
-						// Render bobs
-						// TODO - rendering order?
-						//  This must be defined somehow. Some bobs have a higher
-						//  priority than others. Maybe this priority is a moving
-						//  versus non-moving bobs thing? draw_ground implies that
-						//  this doesn't render map objects. Are there any overdraw
-						//  issues with the current rendering order?
-
-						// Draw Map_Objects hooked to this field
-						if (BaseImmovable * const imm = f.field->get_immovable())
-							imm->draw(egbase, *this, f, f_pos);
-						for
-							(Widelands::Bob * bob = f.field->get_first_bob();
-							 bob;
-							 bob = bob->get_next_bob())
-							bob->draw(egbase, *this, f_pos);
-
-						//  Render overlays on nodes.
-						Overlay_Manager::Overlay_Info
-							overlay_info[MAX_OVERLAYS_PER_NODE];
-
-						const Overlay_Manager::Overlay_Info * const end =
-							overlay_info
-							+
-							overlay_manager.get_overlays(f, overlay_info);
-
-						for
-							(const Overlay_Manager::Overlay_Info * it = overlay_info;
-							 it < end;
-							 ++it)
-							blit(f_pos - it->hotspot, it->pic);
-					}
-				}
-			}
-
-			{ //  Draw things on the R-triangle.
-				const int32_t linear_fx = minfx;
-				FCoords r(Coords(linear_fx, linear_fy2));
-				FCoords b
-					(Coords(linear_fx - not row_is_forward2, linear_fy2 + 1));
-				int32_t posx =
-					(linear_fx - 1) * TRIANGLE_WIDTH
-					+
-					(row_is_forward2 + 1) * (TRIANGLE_WIDTH / 2)
-					-
-					viewofs.x;
-
-				//  Calculate safe (bounded) field coordinates.
-				map.normalize_coords(r);
-				map.normalize_coords(b);
-
-				//  Get field pointers.
-				r.field = &map[Map::get_index(r, mapwidth)];
-				b.field = &map[Map::get_index(b, mapwidth)];
-
-				int32_t count = dx2;
-
-				//  One less iteration than for nodes and D-triangles.
-				while (--count) {
-					const FCoords f = r;
-					map.get_rn(r, &r);
-					map.get_rn(b, &b);
-					posx += TRIANGLE_WIDTH;
-
-					{
-						Overlay_Manager::Overlay_Info overlay_info
-							[MAX_OVERLAYS_PER_TRIANGLE];
-						Overlay_Manager::Overlay_Info const & overlay_info_end =
-							*
-							(overlay_info
-							 +
-							 overlay_manager.get_overlays
-							 	(TCoords<>(f, TCoords<>::R), overlay_info));
-
-						for
-							(Overlay_Manager::Overlay_Info const * it = overlay_info;
-							 it < &overlay_info_end;
-							 ++it)
-							blit
-								(Point
-								 	(posx,
-								 	 posy
-								 	 +
-								 	 (TRIANGLE_HEIGHT
-								 	  -
-								 	  (f.field->get_height()
-								 	   +
-								 	   r.field->get_height()
-								 	   +
-								 	   b.field->get_height())
-								 	  *
-								 	  HEIGHT_FACTOR)
-								 	 /
-								 	 3)
-								 -
-								 it->hotspot,
-								 it->pic);
-					}
-				}
-			}
-
-			{ //  Draw things on the D-triangle.
-				const int32_t linear_fx = minfx;
-				FCoords f(Coords(linear_fx - 1, linear_fy2));
-				FCoords br(Coords(linear_fx - not row_is_forward2, linear_fy2 + 1));
-				int32_t posx =
-					(linear_fx - 1) * TRIANGLE_WIDTH
-					+
-					row_is_forward2 * (TRIANGLE_WIDTH / 2)
-					-
-					viewofs.x;
-
-				//  Calculate safe (bounded) field coordinates.
-				map.normalize_coords(f);
-				map.normalize_coords(br);
-
-				//  Get field pointers.
-				f.field  = &map[Map::get_index(f,  mapwidth)];
-				br.field = &map[Map::get_index(br, mapwidth)];
-
-				int32_t count = dx2;
-
-				while (count--) {
-					const FCoords bl = br;
-					map.get_rn(f, &f);
-					map.get_rn(br, &br);
-					posx += TRIANGLE_WIDTH;
-
-					{
-						Overlay_Manager::Overlay_Info overlay_info
-							[MAX_OVERLAYS_PER_TRIANGLE];
-						const Overlay_Manager::Overlay_Info & overlay_info_end = *
-							(overlay_info
-							 +
-							 overlay_manager.get_overlays
-							 	(TCoords<>(f, TCoords<>::D), overlay_info));
-
-						for
-							(const Overlay_Manager::Overlay_Info * it = overlay_info;
-							 it < &overlay_info_end;
-							 ++it)
-							blit
-								(Point
-								 	(posx,
-								 	 posy
-								 	 +
-								 	 ((TRIANGLE_HEIGHT * 2)
-								 	  -
-								 	  (f.field->get_height()
-								 	   +
-								 	   bl.field->get_height()
-								 	   +
-								 	   br.field->get_height())
-								 	  *
-								 	  HEIGHT_FACTOR)
-								 	 /
-								 	 3)
-								 -
-								 it->hotspot,
-								 it->pic);
-					}
-				}
-			}
-
-			++linear_fy2;
-			row_is_forward2 = not row_is_forward2;
-		}
-	}
-
-	rendermap_deint();
-
-	g_gr->reset_texture_animation_reminder();
-}
-
+using namespace Widelands;
 
 /**
  * Renders a minimap into the current window. The field at viewpoint will be
@@ -973,7 +49,7 @@
  * Calculate the field at the top-left corner of the clipping rect
  * The entire clipping rect will be used for drawing.
  */
-void GameView::renderminimap
+void MiniMapRenderer::renderminimap
 	(Widelands::Editor_Game_Base const &       egbase,
 	 Player                      const * const player,
 	 Point                               const viewpoint,
@@ -986,47 +62,6 @@
 }
 
 
-
-/**
- * Draw ground textures and roads for the given parallelogram (two triangles)
- * into the bitmap.
- *
- * Vertices:
- *   - f_vert vertex of the field
- *   - r_vert vertex right of the field
- *   - bl_vert vertex bottom left of the field
- *   - br_vert vertex bottom right of the field
- *
- * Textures:
- *   - f_r_texture Terrain of the triangle right of the field
- *   - f_d_texture Terrain of the triangle under of the field
- *   - tr_d_texture Terrain of the triangle top of the right triangle ??
- *   - l_r_texture Terrain of the triangle left of the down triangle ??
- *
- *             (tr_d)
- *
- *       (f) *------* (r)
- *          / \  r /
- *  (l_r)  /   \  /
- *        /  d  \/
- *  (bl) *------* (br)
- */
-
-void GameView::draw_field
-	(Rect          & /* subwin */,
-	 Vertex  const &  /* f_vert */,
-	 Vertex  const &  /* r_vert */,
-	 Vertex  const & /* bl_vert */,
-	 Vertex  const & /* br_vert */,
-	 uint8_t         /* roads */,
-	 Texture const & /* tr_d_texture */,
-	 Texture const &  /* l_r_texture */,
-	 Texture const &  /* f_d_texture */,
-	 Texture const &  /* f_r_texture */)
-{
-
-}
-
 /*
  * Blend to colors; only needed for calc_minimap_color below
  */
@@ -1290,7 +325,7 @@
 viewpt is the field at the top left of the rectangle.
 ===============
 */
-void GameView::draw_minimap
+void MiniMapRenderer::draw_minimap
 	(Widelands::Editor_Game_Base const &       egbase,
 	 Widelands::Player           const * const player,
 	 Rect                                const rc,
 
=== renamed file 'src/graphic/render/gameview.h' => 'src/graphic/render/minimaprenderer.h'
--- src/graphic/render/gameview.h	2012-11-24 16:22:10 +0000
+++ src/graphic/render/minimaprenderer.h	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 by the Widelands Development Team
+ * Copyright (C) 2010-2013 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
@@ -17,58 +17,25 @@
  *
  */
 
-#ifndef WIDELANDS_GAMEVIEW_H
-#define WIDELANDS_GAMEVIEW_H
+#ifndef WIDELANDS_MINIMAPRENDERER_H
+#define WIDELANDS_MINIMAPRENDERER_H
+
+#include "graphic/rendertarget.h"
 
 namespace Widelands {
 	struct Player;
 	struct Editor_Game_Base;
 };
 
-struct Vertex;
-struct Texture;
-
-#include "graphic/rendertarget.h"
-
 /**
- * This class does the game rendering. The class is initialized from a
- * RenderTarget and can draw views of the game and the minimap. The game
- * can be rendered to the full screen or to a subwindow. This depends on
- * the RenderTarget from which it was initialized.
- *
- * @todo GameView mixes opengl and software rendering. This should be split
- * properly to have different classes for OpenGL and Software rendering.
- * Perhaps creating a GameRenderManager where different rendering classes can
- * be registered so it is easiely possible to create different game rendering?
+ * This class renders the minimap.
  */
-class GameView : public RenderTarget
+class MiniMapRenderer : public RenderTarget
 {
 public:
-	GameView(RenderTarget & rt) :
+	MiniMapRenderer(RenderTarget & rt) :
 		RenderTarget(rt) {}
-	virtual ~GameView() {}
-
-	/**
-	 * Renders the map from a player's point of view into the current drawing
-	 * window.
-	 *
-	 * Will call the function below when player.see_all().
-	 *
-	 * viewofs is the offset of the upper left corner of the window into the map,
-	 * in pixels.
-	 */
-	void rendermap
-		(Widelands::Editor_Game_Base const &       egbase,
-		 Widelands::Player           const &       player,
-		 Point                                     viewofs);
-
-	/**
-	 * Same as above but not from a player's point of view. Used in game when
-	 * rendering for a player that sees all and the editor.
-	 */
-	void rendermap
-		(Widelands::Editor_Game_Base const & egbase,
-		 Point                               viewofs);
+	virtual ~MiniMapRenderer() {}
 
 	/**
 	 * Render the minimap. If player is not 0, it renders from that player's
@@ -81,22 +48,6 @@
 		 uint32_t                            flags);
 
 protected:
-	/**
-	 * Helper function to draw two terrain triangles. This is called from the
-	 * rendermap() functions.
-	 */
-	virtual void draw_field
-		(Rect          & subwin,
-		 Vertex  const &  f_vert,
-		 Vertex  const &  r_vert,
-		 Vertex  const & bl_vert,
-		 Vertex  const & br_vert,
-		 uint8_t         roads,
-		 Texture const & tr_d_texture,
-		 Texture const &  l_r_texture,
-		 Texture const &  f_d_texture,
-		 Texture const &  f_r_texture);
-
 	/// A helper function to draw the minimap. This is called from
 	/// renderminimap().
 	void draw_minimap
@@ -106,16 +57,6 @@
 		 Point                               viewpt,
 		 Point                               framept,
 		 uint32_t                            flags);
-
-	/**
-	 * This is called before the view of the game is rendered.
-	 */
-	virtual void rendermap_init() {}
-
-	/**
-	* This is called after the view of the game is rendered.
-	*/
-	virtual void rendermap_deint() {}
 };
 
-#endif //WIDELANDS_GAMEVIEW_H
+#endif //WIDELANDS_MINIMAPRENDERER_H
 
=== removed file 'src/graphic/render/terrain_opengl.h'
--- src/graphic/render/terrain_opengl.h	2012-12-07 07:32:24 +0000
+++ src/graphic/render/terrain_opengl.h	1970-01-01 00:00:00 +0000
@@ -1,327 +0,0 @@
-/*
- * Copyright (C) 2010-2012 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- */
-
-#ifdef USE_OPENGL
-#ifndef TERRAIN_OPENGL_H
-#define TERRAIN_OPENGL_H
-
-#include "gl_surface_texture.h"
-#include "vertex.h"
-
-
-void draw_field_opengl
-	(Rect const & subwin,
-	 Vertex const & p1,
-	 Vertex const & p2,
-	 Vertex const & p3,
-	 Texture const & texture,
-	 Texture const & left_texture,
-	 Texture const & top_texture)
-{
-	if (p1.b <= -128 and p2.b <= -128 and p3.b <= -128)
-		return;
-
-	Vertex t1(p1), t2(p2), t3(p3);
-
-	t1.x = p1.x + subwin.x;
-	t1.y = p1.y + subwin.y;
-	t2.x = p2.x + subwin.x;
-	t2.y = p2.y + subwin.y;
-	t3.x = p3.x + subwin.x;
-	t3.y = p3.y + subwin.y;
-
-	if (t1.x < subwin.x and t2.x < subwin.x and t3.x < subwin.x)
-		return;
-	if (t1.y < subwin.y and t2.y < subwin.y and t3.y < subwin.y)
-		return;
-
-	int const subxr = subwin.x + subwin.w;
-	if (t1.x > subxr and t2.x > subxr and t3.x > subxr)
-		return;
-
-	int const subyd = subwin.y + subwin.h;
-	if (t1.y > subyd and t2.y > subyd and t3.y > subyd)
-		return;
-
-	glEnable(GL_BLEND);
-
-	if (g_gr->caps().gl.multitexture) {
-
-		// load current texture
-		glActiveTextureARB(GL_TEXTURE0_ARB);
-		glEnable(GL_TEXTURE_2D);
-		glBindTexture(GL_TEXTURE_2D, texture.getTexture());
-		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-
-		// initialize all texture layers to prevent bug if some layers are skipped
-		for (int i = 1; i < 5; i++) {
-			glActiveTextureARB(GL_TEXTURE0_ARB + i);
-			glEnable(GL_TEXTURE_2D);
-			glBindTexture(GL_TEXTURE_2D, top_texture.getTexture());
-			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
-			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
-		}
-
-		if ((&top_texture != &texture) and not (p1.b == -128 and p3.b == -128)) {
-			// load top texture
-			glActiveTextureARB(GL_TEXTURE1_ARB);
-			glEnable(GL_TEXTURE_2D);
-			glBindTexture(GL_TEXTURE_2D, top_texture.getTexture());
-			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
-			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
-
-			GLuint edge = dynamic_cast<GLSurfaceTexture const &>
-				(*g_gr->get_edge_texture()).get_gl_texture();
-
-			// combine current and top texture
-			glActiveTextureARB(GL_TEXTURE2_ARB);
-			glEnable(GL_TEXTURE_2D);
-			glBindTexture(GL_TEXTURE_2D, edge);
-			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE1_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE);
-			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
-			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
-			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_COLOR);
-		}
-
-		if ((&left_texture != &texture) and not (p1.b == -128 and p2.b == -128)) {
-			// load left texture
-			glActiveTextureARB(GL_TEXTURE3_ARB);
-			glEnable(GL_TEXTURE_2D);
-			glBindTexture(GL_TEXTURE_2D, left_texture.getTexture());
-			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
-			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
-
-			GLuint edge = dynamic_cast<GLSurfaceTexture const &>
-				(*g_gr->get_edge_texture()).get_gl_texture();
-
-			// combine current and left texture
-			glActiveTextureARB(GL_TEXTURE4_ARB);
-			glEnable(GL_TEXTURE_2D);
-			glBindTexture(GL_TEXTURE_2D, edge);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE3_ARB);
-			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE);
-			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
-			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
-			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_COLOR);
-		}
-
-		// Fade effect for fog of war
-		glActiveTextureARB(GL_TEXTURE5_ARB);
-		glEnable(GL_TEXTURE_2D);
-		// texture does not matter but one has to be bound
-		glBindTexture(GL_TEXTURE_2D, texture.getTexture());
-		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
-		glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
-		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
-		glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
-		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR_ARB);
-		glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
-
-		glBegin(GL_TRIANGLES); {
-			{
-				GLfloat const brightness = (150.0 + p1.b) / 150.0;
-				glColor3f(brightness, brightness, brightness);
-			}
-			glMultiTexCoord2iARB(GL_TEXTURE0_ARB, t1.tx, t1.ty);
-			glMultiTexCoord2fARB(GL_TEXTURE1_ARB, t1.tx / TEXTURE_WIDTH, t1.ty / TEXTURE_WIDTH);
-			glMultiTexCoord2fARB(GL_TEXTURE2_ARB, 0, 0);
-			glMultiTexCoord2fARB(GL_TEXTURE3_ARB, t1.tx / TEXTURE_WIDTH, t1.ty / TEXTURE_WIDTH);
-			glMultiTexCoord2fARB(GL_TEXTURE4_ARB, 1, 0);
-			glMultiTexCoord2fARB(GL_TEXTURE5_ARB, t1.tx / TEXTURE_WIDTH, t1.ty / TEXTURE_WIDTH);
-			glVertex2f(t1.x, t1.y);
-
-			{
-				GLfloat const brightness = (150.0 + p2.b) / 150.0;
-				glColor3f(brightness, brightness, brightness);
-			}
-			glMultiTexCoord2iARB(GL_TEXTURE0_ARB, t2.tx, t2.ty);
-			glMultiTexCoord2fARB(GL_TEXTURE1_ARB, t2.tx / TEXTURE_WIDTH, t2.ty / TEXTURE_WIDTH);
-			glMultiTexCoord2fARB(GL_TEXTURE2_ARB, 0.5, 1);
-			glMultiTexCoord2fARB(GL_TEXTURE3_ARB, t2.tx / TEXTURE_WIDTH, t2.ty / TEXTURE_WIDTH);
-			glMultiTexCoord2fARB(GL_TEXTURE4_ARB, 0, 0);
-			glMultiTexCoord2fARB(GL_TEXTURE5_ARB, t2.tx / TEXTURE_WIDTH, t2.ty / TEXTURE_WIDTH);
-			glVertex2f(t2.x, t2.y);
-
-			{
-				GLfloat const brightness = (150.0 + p3.b) / 150.0;
-				glColor3f(brightness, brightness, brightness);
-			}
-			glMultiTexCoord2iARB(GL_TEXTURE0_ARB, t3.tx, t3.ty);
-			glMultiTexCoord2fARB(GL_TEXTURE1_ARB, t3.tx / TEXTURE_WIDTH, t3.ty / TEXTURE_WIDTH);
-			glMultiTexCoord2fARB(GL_TEXTURE2_ARB, 1, 0);
-			glMultiTexCoord2fARB(GL_TEXTURE3_ARB, t3.tx / TEXTURE_WIDTH, t3.ty / TEXTURE_WIDTH);
-			glMultiTexCoord2fARB(GL_TEXTURE4_ARB, 0.5, 1);
-			glMultiTexCoord2fARB(GL_TEXTURE5_ARB, t3.tx / TEXTURE_WIDTH, t3.ty / TEXTURE_WIDTH);
-			glVertex2f(t3.x, t3.y);
-		} glEnd();
-
-		// Cleanup OpenGL
-		glActiveTextureARB(GL_TEXTURE5_ARB);
-		glDisable(GL_TEXTURE_2D);
-		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-		glActiveTextureARB(GL_TEXTURE4_ARB);
-		glDisable(GL_TEXTURE_2D);
-		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-		glActiveTextureARB(GL_TEXTURE3_ARB);
-		glDisable(GL_TEXTURE_2D);
-		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-		glActiveTextureARB(GL_TEXTURE2_ARB);
-		glDisable(GL_TEXTURE_2D);
-		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-		glActiveTextureARB(GL_TEXTURE1_ARB);
-		glDisable(GL_TEXTURE_2D);
-		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-		glActiveTextureARB(GL_TEXTURE0_ARB);
-		glEnable(GL_TEXTURE_2D);
-		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
-	} else {
-		// don't use multitexture
-		glBindTexture(GL_TEXTURE_2D, texture.getTexture());
-		glBegin(GL_TRIANGLES); {
-			{
-				GLfloat const brightness = (150.0 + p1.b) / 150.0;
-				glColor3f(brightness, brightness, brightness);
-			}
-			glTexCoord2i(t1.tx, t1.ty);
-			glVertex2f(t1.x, t1.y);
-
-			{
-				GLfloat const brightness = (150.0 + p2.b) / 150.0;
-				glColor3f(brightness, brightness, brightness);
-			}
-			glTexCoord2i(t2.tx, t2.ty);
-			glVertex2f(t2.x, t2.y);
-
-			{
-				GLfloat const brightness = (150.0 + p3.b) / 150.0;
-				glColor3f(brightness, brightness, brightness);
-			}
-			glTexCoord2i(t3.tx, t3.ty);
-			glVertex2f(t3.x, t3.y);
-		} glEnd();
-	}
-}
-
-#define horiz_road_opengl(tex, start, end)                                    \
-   glBindTexture( GL_TEXTURE_2D, tex);                                        \
-   glBegin(GL_QUADS); {                                                       \
-      glTexCoord2i(0, 0);                                                     \
-      glVertex2f(subwin.x + start.x, subwin.y + start.y - 2);                 \
-      glTexCoord2i(TEXTURE_WIDTH, 0);                                         \
-      glVertex2f(subwin.x + end.x,   subwin.y + end.y - 2);                   \
-      glTexCoord2i(TEXTURE_WIDTH, 4);                                         \
-      glVertex2f(subwin.x + end.x,   subwin.y + end.y + 2);                   \
-      glTexCoord2i(0, 4);                                                     \
-      glVertex2f(subwin.x + start.x, subwin.y + start.y + 2);                 \
-   } glEnd();                                                                 \
-
-#define vert_road_opengl(tex, start, end)                                     \
-   glBindTexture( GL_TEXTURE_2D, tex);                                        \
-   glBegin(GL_QUADS); {                                                       \
-      glTexCoord2i(0, 0);                                                     \
-      glVertex2f(subwin.x + start.x - 3, subwin.y + start.y);                 \
-      glTexCoord2i(6, 0);                                                     \
-      glVertex2f(subwin.x + start.x + 3, subwin.y + start.y);                 \
-      glTexCoord2i(TEXTURE_WIDTH, TEXTURE_HEIGHT);                            \
-      glVertex2f(subwin.x + end.x + 3,   subwin.y + end.y);                   \
-      glTexCoord2i(TEXTURE_WIDTH - 6, TEXTURE_HEIGHT);                        \
-      glVertex2f(subwin.x + end.x - 3,   subwin.y + end.y);                   \
-   } glEnd();                                                                 \
-
-void draw_roads_opengl
-	(Rect & subwin,
-	 uint8_t roads,
-	 Vertex const & f_vert,
-	 Vertex const & r_vert,
-	 Vertex const & bl_vert,
-	 Vertex const & br_vert)
-{
-	uint8_t road;
-
-	GLuint rt_normal =
-		dynamic_cast<GLSurfaceTexture const &>
-		(*g_gr->get_road_texture(Widelands::Road_Normal)).get_gl_texture();
-	GLuint rt_busy   =
-		dynamic_cast<GLSurfaceTexture const &>
-		(*g_gr->get_road_texture(Widelands::Road_Busy)).get_gl_texture();
-
-	glDisable(GL_BLEND);
-	glColor4f(1.0f, 1.0f, 1.0f, 0.6f);
-
-	road = (roads >> Widelands::Road_East) & Widelands::Road_Mask;
-	if ((-128 < f_vert.b or -128 < r_vert.b) and road) {
-		switch (road) {
-		case Widelands::Road_Normal:
-			horiz_road_opengl(rt_normal, f_vert, r_vert)
-			break;
-		case Widelands::Road_Busy:
-			horiz_road_opengl(rt_busy, f_vert, r_vert)
-			break;
-		default:
-			assert(false);
-		}
-	}
-
-	road = (roads >> Widelands::Road_SouthEast) & Widelands::Road_Mask;
-	if ((-128 < f_vert.b or -128 < br_vert.b) and road) {
-		switch (road) {
-		case Widelands::Road_Normal:
-			vert_road_opengl(rt_normal, f_vert, br_vert);
-			break;
-		case Widelands::Road_Busy:
-			vert_road_opengl(rt_busy, f_vert, br_vert);
-			break;
-		default:
-			assert(false);
-		}
-	}
-
-	road = (roads >> Widelands::Road_SouthWest) & Widelands::Road_Mask;
-	if ((-128 < f_vert.b or -128 < bl_vert.b) and road) {
-		switch (road) {
-		case Widelands::Road_Normal:
-			vert_road_opengl(rt_normal, f_vert, bl_vert);
-			break;
-		case Widelands::Road_Busy:
-			vert_road_opengl(rt_busy, f_vert, bl_vert);
-			break;
-		default:
-			assert(false);
-		}
-	}
-}
-
-#endif
-#endif
 
=== modified file 'src/graphic/rendertarget.h'
--- src/graphic/rendertarget.h	2012-12-15 18:40:59 +0000
+++ src/graphic/rendertarget.h	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002-2004, 2006-2010 by the Widelands Development Team
+ * Copyright (C) 2002-2004, 2006-2013 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
@@ -88,6 +88,8 @@
 	void reset();
 
 	Surface* get_surface() {return m_surface;}
+	const Rect & get_rect() const {return m_rect;}
+	const Point & get_offset() const {return m_offset;}
 
 protected:
 	bool clip(Rect & r) const throw ();
 
=== modified file 'src/logic/instances.h'
--- src/logic/instances.h	2013-02-03 10:44:13 +0000
+++ src/logic/instances.h	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002-2004, 2006-2011 by the Widelands Development Team
+ * Copyright (C) 2002-2004, 2006-2013 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
 
=== modified file 'src/logic/tribe.h'
--- src/logic/tribe.h	2013-02-03 10:44:13 +0000
+++ src/logic/tribe.h	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002, 2006-2011 by the Widelands Development Team
+ * Copyright (C) 2002, 2006-2013 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
 
=== modified file 'src/logic/world.cc'
--- src/logic/world.cc	2012-11-30 22:10:10 +0000
+++ src/logic/world.cc	2013-02-09 12:25:26 +0000
@@ -821,6 +821,7 @@
 m_name              (s->get_name()),
 m_descname          (s->get_string("name", s->get_name())),
 m_frametime         (FRAME_LENGTH),
+m_dither_layer   (0),
 m_valid_resources   (0),
 m_nr_valid_resources(0),
 m_default_resources (-1),
@@ -896,6 +897,8 @@
 			throw game_data_error("%s: invalid type '%s'", m_name.c_str(), is);
 	}
 
+	m_dither_layer = s->get_int("dither_layer", 0);
+
 	// Determine template of the texture animation pictures
 	char fnametmpl[256];
 
 
=== modified file 'src/logic/world.h'
--- src/logic/world.h	2012-11-30 22:10:10 +0000
+++ src/logic/world.h	2013-02-09 12:25:26 +0000
@@ -113,6 +113,7 @@
 	int32_t get_default_resources_amount() const throw () {
 		return m_default_amount;
 	}
+	int32_t dither_layer() const {return m_dither_layer;}
 
 private:
 	const std::string m_name;
@@ -121,12 +122,13 @@
 	uint32_t    m_frametime;
 	uint8_t   m_is;
 
+	int32_t m_dither_layer;
+
 	uint8_t         * m_valid_resources;
 	uint8_t           m_nr_valid_resources;
 	int8_t            m_default_resources;
 	int32_t           m_default_amount;
 	uint32_t          m_texture; //  renderer's texture
-
 };
 
 struct MapGenInfo;
 
=== modified file 'src/point.h'
--- src/point.h	2012-09-21 21:36:07 +0000
+++ src/point.h	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002-2004, 2006-2007 by the Widelands Development Team
+ * Copyright (C) 2002-2004, 2006-2013 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
@@ -44,6 +44,9 @@
 	Point   operator+  (const Point & other) const {
 		return Point(x + other.x, y + other.y);
 	}
+	Point   operator-  () const {
+		return Point(-x, -y);
+	}
 	Point   operator-  (const Point & other) const {
 		return Point(x - other.x, y - other.y);
 	}
 
=== modified file 'src/rect.h'
--- src/rect.h	2013-02-04 21:52:38 +0000
+++ src/rect.h	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002-2004, 2006-2010 by the Widelands Development Team
+ * Copyright (C) 2002-2004, 2006-2013 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
 
=== modified file 'src/wui/mapview.cc'
--- src/wui/mapview.cc	2012-12-16 14:29:46 +0000
+++ src/wui/mapview.cc	2013-02-09 12:25:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002-2004, 2006-2011 by the Widelands Development Team
+ * Copyright (C) 2002-2004, 2006-2013 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,7 +19,6 @@
 
 #include "mapview.h"
 
-
 #include "interactive_base.h"
 #include "interactive_player.h"
 #include "mapviewpixelfunctions.h"
@@ -30,9 +29,8 @@
 
 #include "graphic/graphic.h"
 #include "graphic/rendertarget.h"
-#include "graphic/render/gameview.h"
-#include "graphic/render/gameview_opengl.h"
-#include "graphic/render/gameview_sdl.h"
+#include "graphic/render/gamerenderer_gl.h"
+#include "graphic/render/gamerenderer_sdl.h"
 
 #include "upcast.h"
 
@@ -48,6 +46,11 @@
 m_complete_redraw_needed(true)
 {}
 
+Map_View::~Map_View()
+{
+	// explicit destructor so that smart pointer destructors
+	// with forward-declared types are properly instantiated
+}
 
 /// Moves the mouse cursor so that it is directly above the given node
 void Map_View::warp_mouse_to_node(Widelands::Coords const c) {
@@ -95,21 +98,21 @@
 
 	egbase.map().overlay_manager().load_graphics();
 
-	GameView * gameview;
+	if (!m_renderer) {
 #ifdef USE_OPENGL
-	if (g_opengl) {
-		gameview = new GameViewOpenGL(dst);
-	} else
+		if (g_opengl) {
+			m_renderer.reset(new GameRendererGL());
+		} else
 #endif
-	{
-		gameview = new GameViewSDL(dst);
+		{
+			m_renderer.reset(new GameRendererSDL());
+		}
 	}
 	if (upcast(Interactive_Player const, interactive_player, &intbase())) {
-		gameview->rendermap(egbase, interactive_player->player(), m_viewpoint);
+		m_renderer->rendermap(dst, egbase, interactive_player->player(), m_viewpoint);
 	} else {
-		gameview->rendermap(egbase, m_viewpoint);
+		m_renderer->rendermap(dst, egbase, m_viewpoint);
 	}
-	delete gameview;
 
 	m_complete_redraw_needed = false;
 	draw_tooltip(dst, tooltip());
 
=== modified file 'src/wui/mapview.h'
--- src/wui/mapview.h	2012-02-15 21:25:34 +0000
+++ src/wui/mapview.h	2013-02-09 12:25:26 +0000
@@ -27,6 +27,7 @@
 
 #include "ui_basic/panel.h"
 
+struct GameRenderer;
 struct Interactive_Base;
 
 /**
@@ -45,6 +46,7 @@
 		(UI::Panel * const parent,
 		 const int32_t x, const int32_t y, const uint32_t w, const uint32_t h,
 		 Interactive_Base &);
+	virtual ~Map_View();
 
 	void set_changeview(const ChangeViewFn & fn);
 
@@ -83,6 +85,7 @@
 private:
 	void stop_dragging();
 
+	boost::scoped_ptr<GameRenderer> m_renderer;
 	Interactive_Base & m_intbase;
 	ChangeViewFn m_changeview;
 	Point              m_viewpoint;
 
=== modified file 'src/wui/minimap.cc'
--- src/wui/minimap.cc	2012-12-13 10:41:22 +0000
+++ src/wui/minimap.cc	2013-02-09 12:25:26 +0000
@@ -26,7 +26,7 @@
 
 #include "graphic/graphic.h"
 #include "graphic/rendertarget.h"
-#include "graphic/render/gameview.h"
+#include "graphic/render/minimaprenderer.h"
 
 
 MiniMap::View::View
@@ -60,9 +60,9 @@
 
 void MiniMap::View::draw(RenderTarget & dst)
 {
-	GameView gameview(dst);
+	MiniMapRenderer mmr(dst);
 
-	gameview.renderminimap
+	mmr.renderminimap
 		(m_ibase.egbase(),
 		 m_ibase.get_player(),
 		 (*m_flags) & (MiniMap::Zoom2) ?
 
=== modified file 'worlds/blackland/terrainconf'
--- worlds/blackland/terrainconf	2012-02-15 21:25:34 +0000
+++ worlds/blackland/terrainconf	2013-02-09 12:25:26 +0000
@@ -7,75 +7,91 @@
 name="Ashes"
 def_resources=water 5
 is=green
+dither_layer=20
 
 [mountain1]
 name="Mountain1"
-resources=coal, iron, gold, granit 
+resources=coal, iron, gold, granit
 is=mountain
+dither_layer=50
 
 [lava-stone1]
 name="Lava stone1"
 is=acid
+dither_layer=70
 
 [lava-stone2]
 name="Lava stone2"
 is=acid
+dither_layer=70
 
 [strand]
 name="Beach"
 is=dry
+dither_layer=10
 
 [water]
 name="Water"
 def_resources=fish 4
 is=water
 fps=14
+dither_layer=0
 
 [hardground1]
 name="Hardground1"
 def_resources=water 10
 is=green
+dither_layer=30
 
 [hardground2]
 name="Hardground2"
 def_resources=water 10
 is=green
+dither_layer=30
 
 [hardground3]
 name="Hardground3"
 def_resources=water 10
 is=green
+dither_layer=30
 
 [mountain2]
 name="Mountain2"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=50
 
 [mountain3]
 name="Mountain3"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=50
 
 [mountain4]
 name="Mountain4"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=50
 
 [ashes2]
 name="Ashes2"
 def_resources=water 4
 is=green
+dither_layer=20
 
 [hardground4]
 name="Hardground4"
 def_resources=water 10
 is=green
+dither_layer=30
 
 [lava]
 name="Lava"
 is=acid
+dither_layer=60
 
 [hardlava]
 name="Hard lava"
 is=green
+dither_layer=40
 
 
=== modified file 'worlds/desert/terrainconf'
--- worlds/desert/terrainconf	2012-02-15 21:25:34 +0000
+++ worlds/desert/terrainconf	2013-02-09 12:25:26 +0000
@@ -7,66 +7,80 @@
 [desert1]
 name="Desert1"
 is=dry
+dither_layer=20
 
 [desert2]
 name="Desert2"
 is=dry
+dither_layer=20
 
 [desert3]
 name="Desert3"
 is=dry
+dither_layer=20
 
 [desert4]
 name="Desert4"
 def_resources=water 2
 is=green
+dither_layer=20
 
 [drysoil]
 name="Dry soil"
 def_resources=water 4
 is=green
+dither_layer=30
 
 [beach]
 name="Beach"
 is=dry
+dither_layer=10
 
 [steppe]
 name="Steppe"
 def_resources=water 5
 is=green
+dither_layer=30
 
 [meadow]
 name="Meadow"
 def_resources=water 10
 is=green
+dither_layer=40
 
 [mountainmeadow]
 name="Mountain meadow"
 is=green
+dither_layer=50
 
 [highmountainmeadow]
 name="High mountain meadow"
 is=green
+dither_layer=60
 
 [mountain1]
 name="Mountain1"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=70
 
 [mountain2]
 name="Mountain2"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=70
 
 [mountain3]
 name="Mountain3"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=70
 
 [mountain4]
 name="Mountain4"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=70
 
 
 ##### Here are few imported textures of greenland
@@ -76,7 +90,9 @@
 def_resources=fish 4
 is=water
 fps=5
+dither_layer=0
 
 [lava]
 name="Lava"
 is=acid
+dither_layer=80
 
=== modified file 'worlds/greenland/terrainconf'
--- worlds/greenland/terrainconf	2012-02-15 21:25:34 +0000
+++ worlds/greenland/terrainconf	2013-02-09 12:25:26 +0000
@@ -7,76 +7,92 @@
 name="Steppe"
 def_resources=water 5
 is=green
+dither_layer=20
 
 [berg1]
 name="Mountain1"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=60
 
 [schnee]
 name="Snow"
 is=dead
+dither_layer=70
 
 [sumpf]
 name="Swamp"
 def_resources=water 20
 is=unpassable
 fps=14
+dither_layer=30
 
 [strand]
 name="Beach"
 is=dry
+dither_layer=10
 
 [wasser]
 name="Water"
 def_resources=fish 4
 is=water
 fps=14
+dither_layer=0
 
 [wiese1]
 name="Meadow1"
 def_resources=water 10
 is=green
+dither_layer=40
 
 [wiese2]
 name="Meadow2"
 def_resources=water 10
 is=green
+dither_layer=40
 
 [wiese3]
 name="Meadow3"
 def_resources=water 10
 is=green
+dither_layer=40
 
 [berg2]
 name="Mountain2"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=60
 
 [berg3]
 name="Mountain3"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=60
 
 [berg4]
 name="Mountain4"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=60
 
 [steppe_kahl]
 name="Barren steppe"
 def_resources=water 4
 is=green
+dither_layer=20
 
 [wiese4]
 name="Meadow4"
 def_resources=water 10
 is=green
+dither_layer=40
 
 [lava]
 name="Lava"
 is=acid
+dither_layer=80
 
 [bergwiese]
 name="Mountain meadow"
 is=green
+dither_layer=50
 
=== modified file 'worlds/winterland/terrainconf'
--- worlds/winterland/terrainconf	2012-02-15 21:25:34 +0000
+++ worlds/winterland/terrainconf	2013-02-09 12:25:26 +0000
@@ -7,77 +7,93 @@
 name="Tundra"
 def_resources=water 5
 is=green
+dither_layer=50
 
 [mountain1]
 name="Mountain1"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=70
 
 [ice_flows]
 name="Ice flows"
 is=water
 fps=5
+dither_layer=10
 
 [ice_flows2]
 name="Ice flows2"
 is=water
 fps=5
+dither_layer=20
 
 [ice]
 name="Ice"
 is=dry
 #### of course ice is not dry, but this disallows the users, to build on snow. only flags are allowed. ;-)
+dither_layer=30
 
 [water]
 name="Water"
 def_resources=fish 4
 is=water
 fps=8
+dither_layer=0
 
 [tundra_taiga]
 name="Tundra taiga"
 def_resources=water 10
 is=green
+dither_layer=50
 
 [tundra2]
 name="Tundra2"
 def_resources=water 10
 is=green
+dither_layer=50
 
 [tundra3]
 name="Tundra3"
 def_resources=water 10
 is=green
+dither_layer=50
 
 [mountain2]
 name="Mountain2"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=70
 
 [mountain3]
 name="Mountain3"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=70
 
 [mountain4]
 name="Mountain4"
 resources=coal, iron, gold, granit
 is=mountain
+dither_layer=70
 
 [strand]
 name="Beach"
 is=dry
+dither_layer=40
 
 [taiga]
 name="Taiga"
 def_resources=water 10
 is=green
+dither_layer=50
 
 [lava]
 name="Lava"
 is=acid
+dither_layer=80
 
 [snow]
 name="Snow"
 def_resources=water 30
 is=green
+dither_layer=60