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

[SirVer]

- Build a texture atlas with the most commonly used images on startup.
- Mild refactorings in the graphic initialization.
- Add a caching mechanism to remember OpenGL state like bound textures, framebuffers, and so on. Use this to avoid unneeded calls into the driver.
- Combine all different blit programs into one and use a if in the fragment shader. This allows for more batching, taking load from the CPU and transferring it to the GPU.
- Apply suggestion by nha: Recreate buffers on the GPU on each frame instead of trying to reuse the memory.

These are the improvements that this buys: All benchmarks where run at 60 FPS, 3440x1440 resolution & fullscreen, on a map with lots of buildings, lots of textures on the screen, lots of different map objects. The game was paused, so that no logic code ate CPU. Census & statistics were disabled since they do not benefit from the texture atlas at all.

pre renderqueue (revision 7691): ~90% CPU load, 41000 OpenGL calls per frame.
post renderqueue (revision 7695): ~65% CPU load, 18300 OpenGL calls per frame.
This commit: 28% CPU load, 3000 OpenGL calls per frame.

An experimental version that loaded every image in Widelands into one 16kx16k texture atlas (1 GB of GPU RAMs was needed): 18% CPU load, 209 OpenGL calls. This proved unsustainable for most GPUs so it was dropped again.

Worst to best rendering now only takes 32% CPU and 8% GL calls of what it used to.

Possible improvements: The atlas creating could also compress the images by finding unchanging areas in animation. This would drastically reduce the size of the atlas and the use of GPU memory. This is described in bug 1121982. I am not motivated to work on this now though and I only consider it a nice to have.

Use the texture atlas + GL optimization. I am reasonably happy with the draw performance of Widelands now.

[bunnybot (widelandsofficial)]

Hi, I am bunnybot (https://github.com/widelands/bunnybot).

I am keeping the source branch lp:~widelands-dev/widelands/use_image_cache mirrored to https://github.com/widelands/widelands/tree/_widelands_dev_widelands_use_image_cache

You can give me commands by starting a line with @bunnybot <command>. I understand:
 merge: Merges the source branch into the target branch, closing the merge proposal. I will use the proposed commit message if it is set.

[bunnybot (widelandsofficial)]

Travis build 233 has changed state to: failed. Details: https://travis-ci.org/widelands/widelands/builds/101329419.

[Nicolai Hähnle (nha)]

This is an impressive improvement! Out of curiosity, how large does the texture atlas end up being?

I have mostly looked at the actual drawing code (I did notice a merge conflict marker in world.cc though, and bunnybot probably did, too ;)). As I already said today on IRC, for desktop OpenGL you should really use instancing. You can copy the Arguments structure almost 1:1 into a buffer with per-instance data and use a simple vertex shader to reduce the CPU load. I'd understand if you don't want separate paths for OpenGL ES 2.0 though.

The next-best thing I noticed is using glMapBuffer to avoid an unnecessary copy. Right now you fill the vertices_ vector (first "copy"). Then glBufferData copies the vertex data into the buffer object (second copy). And finally the vertex data gets uploaded to/pulled by the GPU.

Since you know the number of vertices up-front, it would be better to use glBufferData(..., NULL, ...) to reserve the required amount of space, then use glMapBuffer and write the vertex data directly into the buffer object, thus avoiding the second copy. (This would also apply to

(And now that I've written this, I notice that GLES 2.0 apparently doesn't have glMapBuffer... *sigh*)

Third, it would almost certainly be beneficial to use an element array. That would reduce the amount of vertex data you need to write by one third, and would also reduce the vertex shader load on the GPU by up to one third (Widelands almost certainly isn't shader bound, but hey... perhaps it saves some power). The element array can even be completely static - it just needs to grow as needed during application warm-up.

For the buffer handling, the following is actually best for the kind of streaming draw that Widelands is doing:
1. Determine a reasonably large buffer size N.
2. Use a single buffer object, initialized with glBufferData(..., N, NULL, GL_STREAM_DRAW);
3. As you go along drawing a frame, fill the buffer object from front to back. For all vertex data that you write, use glMapBufferRange to map _exactly_ the range that you want to write for the next draw call, then unmap, then do the draw call.
4. When the vertex data for the next draw call wouldn't fit in the remaining space of the buffer, start from the front, but (and this is VERY important, I've seen plenty of applications screw this up) add the GL_MAP_INVALIDATE_BUFFER_BIT.

What happens when you do this is that the driver magically maintains a pool of underlying buffers, all of size N. Whenever you start from 0 with the MAP_INVALIDATE_BUFFER_BIT, the driver switches the underlying buffer to one from the pool that is no longer in-flight. As far as I know, all desktop GL drivers do this.

Now you see that the patch I sent isn't actually optimal. It would be even better to do something like this:

GLsizeiptr bytes = items.size() * sizeof(T);

if (bytes > size_) {
  glBufferData(GL_ARRAY_BUFFER, bytes, items.data(), GL_STREAM_DRAW);
  size_ = bytes;
  filled_ = bytes;
} else {
  GLbitfield access = GL_MAP_WRITE_BIT;

  if (filled_ + bytes > size_) {
    filled_ = 0;
    access |= GL_MAP_INVALIDATE_BUFFER_BIT;
  }

  void *map = glMapBufferRange(GL_ARRAY_BUFFER, filled_, bytes, access);
  memc...

[SirVer (sirver)]

> This is an impressive improvement! Out of curiosity, how large does the texture atlas end up being?

All images fit into 16kx16k, but since most GPUs seem to support 8k we have 2 textures. This could be improved by doing what we started once before, but never finished: compactifying the animations by finding common rectangles. This could be done when the atlas is constructed and would reduce memory foodprint a lot.

[Element Array]
I did experiment with an element array for a bit and it seems to buy some CPU too, but I had trouble keeping this indirection in my head during coding, so I cut it eventually. I agree that it would be better design.

[Buffer magic]
That sounds interesting, but would require some redesign in the current draw approach. I am very weary working on OpenGL related stuff, so I'll call it good enough for now. If you are interested in experimenting further, that would of course be greatly appreciated!

[kaputtnik (franku)]

Thanks for adding the file :-) I just compile and want to test.

[Tino (tino79)]

Compiles and runs fine on windows. I would really like to see this land in trunk as soon as possible.

review: Approve

[kaputtnik (franku)]

Yes, great enhancement. No flickering anymore (which came up with the new font renderer):
- Fixes bug 1509791
- may this could help also fixing the bug related to some wrong colored shadows? See bug 1519361

A suggestion, if possible. After the image atlas is created a black "Loading images" screen appears. It would be nice if the splash screen (the one where one has to click) could be used as the background for "Loading images". And yes, of course, a progress bar when creating the texture atlas ... :-D

review: Approve

[Tino (tino79)]

Currently the images in campaigns are not cached.
Starting any campaign mission fails.

review: Needs Fixing

[bunnybot (widelandsofficial)]

Travis build 235 has changed state to: passed. Details: https://travis-ci.org/widelands/widelands/builds/101396647.

[SirVer (sirver)]

Images in campaigns are fixed now.

review: Needs Resubmitting

[Nicolai Hähnle (nha)]

I wanted to test this branch on my laptop right now, and I have to say it's a bit of a nightmare, all of which can be roughly summarized as "this is probably not a good idea when VRAM is small". Let me list a number of problems in no particular order:

1) Our driver correctly announces support for textures up to 16384 in size, but when you actually allocate such a texture, it is 1GB large, which is going to fail when VRAM is not that big. So that possibility is something that the code should account for.

2) It seems there are plenty of fun bugs in our driver when textures become gigantic, so on the plus side, this is a great test case for making our driver more robust...

3) When I force max_size to 4096, I no longer hit critical driver bugs (only ones leading to rendering errors, oh well). There is still a problem though because the atlas textures add up to something like 110 million texels, which means that the textures are going to take more than 400MB (okay, maybe slightly under since there are also mask textures), which means that on integrated GPUs, you get texture thrashing. (Mine has a 512MB VRAM reservation, and whether it starts thrashing or not seems to depend on what compiz is currently doing - if I only had a single monitor running Widelands fullscreen it would probably okay, but as is performance is occasionally killed completely.)

Even without texture atlases, an integrated GPU is going to swap textures occasionally, but it's going to happen much less because the working set is smaller. With texture atlases, your working set is going to be everything almost all of the time.

This sucks. Summary:

(1) Trying to reduce the atlas size is more important than you thought.

(2) Probably the best quick fix option you have is to check VRAM size (e.g. using GLX_MESA_query_renderer) and add some heuristic to disable texture atlases below a certain VRAM size. It should be possible to override the heuristic via the command line. It's kind of sad that you then have a performance optimization that doesn't help the hardware that needs it most...

(3) A longer term fix could be some kind of texture streaming. I actually don't know the best way to do this.

review: Needs Fixing

[SirVer (sirver)]

Nicolai, could you outline what VRAM means in this case? I did not understand a lot of your last post, it is full of things that I have no understanding of.

So far the only feedback I got is that this change improves the performance - I tested it on old macs too which has only integrated graphics.

[TiborB (tiborb95)]

If there is such problem it must be discussed thoroughly.

I just tested it on my linux box, with integrated intel HD 4000 and 8 GB RAM (this probably matters much) and no visible problems and it seems to be running nicely.

I googled a bit how to find out VRAM or whatever it is and found two commands (for linux):

$ dmesg | grep Memory
......
[ 6.992863] [drm] Memory usable by graphics device = 2048M

$ LC_ALL=C lspci -v | grep -EA10 "3D|VGA" | grep 'prefetchable'
 Memory at f7800000 (64-bit, non-prefetchable) [size=4M]
 Memory at e0000000 (64-bit, prefetchable) [size=256M]

It seems the first one shows maximum (2GB) and second one actual usage (256MB) - but I am not sure of interpretation...

But as I said - it runs OK here. Perhaps if more peoples tested it...

[Nicolai Hähnle (nha)]

VRAM is Video RAM, which in the case of integrated graphics is a part of the physical RAM which is reserved for the GPU. Run `free` to get an idea of how large it is approximately: the total memory shown will be less than the physical amount of RAM, reflecting how much is available to the CPU.

In addition, there's the GTT or GART, which is a virtual memory aperture through which the GPU can access system RAM. If not all data fits into VRAM, the GPU can still render from the GTT, but it tends to be slower. The 2048M shown in the dmesg log are probably VRAM + GTT.

It's possible that since Widelands doesn't use that much bandwidth, rendering from GTT (typically 1-2GB) would be fine.

Please do provide an option to disable the texture atlas, and I'll see what can be done about our driver.

[TiborB (tiborb95)]

@nha
Thanks for clarification.
I noticed when experimenting with this that it disabled (crashed ?) compton - this is a lightweight desktop 3D acceleration - but no big deal for me. So perhaps if you disabled compiz...
Also I wonder if the game will be capable to run in VirtualBox, but I dont have any virtual system at hand to test it...

[GunChleoc (gunchleoc)]

I have a VMWare VM, so I could eventually test it. I want to review the prerequisite branch first though (the VM makes my whole machine slow when linking...)

[TiborB (tiborb95)]

AFAIK VirtualBox is bit worse in regard to 3D acceleration, but testing in VMWare is also very usefull

[SirVer (sirver)]

I will look into running with a minimal texture atlas through a commandline option and profile how much performance that cost on my system.

Probably not before the weekend though.

In the meantime, more testing with virtual machines would be great!

[TiborB (tiborb95)]

I can not start it in VirtualBox (Mint in Arch linux) - I am getting segmentation fault while building the texture. But virtualbox simply is not good enough virtualization tool for running such game inside a guest I think

[SirVer (sirver)]

I need another round of testing, please.

I modified the code to only pack terrains, roads and tribe borders and the pics/ subdirectory into a texture atlas and load all other graphics as needed from disk. This is what Nicolai requested - the code requires terrains and roads to be in the same texture, so we need this minimal atlas always.

In my tests, the performance for this is comparable to using one atlas with 2048x2048 textures. It needs ~29% CPU and 3300 GL calls per frame. This is still less than half of what trunk currently needs (60% CU, 18300 GL calls), but not as good as one huge atlas (18% CPU, 210 GL calls).

Advantages of this are: building the atlas is very quick and there is no need to cache. Could I get some testing feedback?

[kaputtnik (franku)]

Runs fine, the time to create the atlas and loading images is very short on my old AMD CPU. Tested editor and a save game. File sizes:

ls -lh
insgesamt 2,4M
-rw-r--r-- 1 kaputtnik users 79K 14. Jan 16:36 texture_atlas.lua
-rw-r--r-- 1 kaputtnik users 2,3M 14. Jan 16:36 texture_atlas_00.png

CPU usage after loading a 5hrs save game:
This branch: ~32%
Current trunk: ~54%

[TiborB (tiborb95)]

Well, it compiled, building of that cache was fast, BUT I see a lot of output like this in console:

Image with hash tribes/workers/barbarians/lumberjack/walk_ne_08_pc.png not found. Loading from disk.
Image with hash tribes/workers/barbarians/lumberjack/walk_ne_09_pc.png not found. Loading from disk.

???

[SirVer (sirver)]

I changed the code back to load an image from disk if it was not already loaded. That is the current behavior in trunk too. I just added logging to get a feeling how often that actually happens. I'll remove it before merging.

nicolai, if you undo the last commit you have the originial behavior that creates a huge atlas if it can. I'll rework this branch to no longer cache the texture atlas and instead just regenerate the one with the most common images every time the game launches. We might revisit packing everything into an atlas once we go back to bug 1121982.

[TiborB (tiborb95)]

So it will not built it at once on start, but instead it will expand it on the fly as new images are needed during the game? Correct?

[SirVer (sirver)]

no. sorry, that explanation was confusing.

It will immediately on start build a small one (~1024x1200 pixels) that contains frequently used images like the UI elements, buildhelp & the roads and world textures. Every other image will be loaded as needed from disk and put into a separate texture each, i.e. no texture atlas.

[TiborB (tiborb95)]

OK, I like it.
And I think there will be no more testers, unless GunChleoc shows up.
I am willing to approve it if you think my approval is sufficient.

Of course there is still some NOCOM in diff and you have to mute a logging about images as you mentioned.

BTW, windows builds were tested?

[SirVer (sirver)]

Okay, I simplified the code as there is no need to cache the images anymore on disk - building the atlas is fast. I updated the commit message, merged trunk and removed codecheck warnings. Tibor, if you approve of the code, could you merge it in?

review: Needs Resubmitting

[GunChleoc (gunchleoc)]

I'm online today, so I can do some testing.

[kaputtnik (franku)]

Is there a great difference between fullscreen and window mode? I used windowed mode to have the task manager open to see the CPU usage.

I just tested a little game on my laptop and this branch as current trunk uses about 12% CPU... So no difference?

[SirVer (sirver)]

fullscreen and window will likely not make a huge difference. But the size of the widelands drawing area (i.e. resolution in game) and the amount of objects on it. The more different objects (terrains, roads, buildings, workers, critters and windows) the higher the difference in load.

Also make sure to pause the game, otherwise the game logic will interfere with your benchmark.

If your GPU is super quick at swapping textures, the difference to the renderqueue branch might be small. However, this branch should in no case be slower than trunk.

[GunChleoc (gunchleoc)]

I gave this a quick spin in my VM and it runs fine. There is a problem with drawing rectangles though - got probably introduced in one of the previous graphics branches.

https://launchpadlibrarian.net/234364565/rectangles.png

[SirVer (sirver)]

I think this is https://bugs.launchpad.net/widelands/+bug/1531114. I will look into that soonish. Can this branch go in?

[TiborB (tiborb95)]

I have the same problem as GunChleoc - though I did not notice it.

Otherwise, it works nicely

[TiborB (tiborb95)]

I am all for merging it.

review: Approve

[GunChleoc (gunchleoc)]

Looks like my bug is https://bugs.launchpad.net/widelands/+bug/1531114 indeed - seems more pronounced with small screen resolutions maybe?

I won't have time to look at the code until end of next week, but if everything has been checked, it can go in.

[SirVer (sirver)]

Thanks for testing everybody! Thanks for reviewing, Tibor.

@bunnybot merge

=== modified file 'src/editor/ui_menus/editor_tool_set_terrain_options_menu.cc'
--- src/editor/ui_menus/editor_tool_set_terrain_options_menu.cc	2016-01-08 21:00:39 +0000
+++ src/editor/ui_menus/editor_tool_set_terrain_options_menu.cc	2016-01-16 20:47:43 +0000
@@ -51,7 +51,7 @@
 	std::vector<std::string> tooltips;
 
 	// Blit the main terrain image
-	const Texture& terrain_texture = terrain_descr.get_texture(0);
+	const Image& terrain_texture = terrain_descr.get_texture(0);
 	Texture* texture = new Texture(terrain_texture.width(), terrain_texture.height());
 	texture->blit(Rect(0, 0, terrain_texture.width(), terrain_texture.height()),
 					  terrain_texture,
 
=== modified file 'src/graphic/CMakeLists.txt'
--- src/graphic/CMakeLists.txt	2016-01-07 12:47:17 +0000
+++ src/graphic/CMakeLists.txt	2016-01-16 20:47:43 +0000
@@ -3,19 +3,16 @@
 # TODO(sirver): Separate this directory into a base directory and one
 # that is Widelands aware (can include logic stuff).
 
-# A binary that creates and writes out a texture atlas of all images in
-# a directory.
-wl_binary(wl_make_texture_atlas
+wl_library(graphic_build_texture_atlas
   SRCS
-    make_texture_atlas_main.cc
+    build_texture_atlas.h
+    build_texture_atlas.cc
   DEPENDS
-    base_log
     graphic
     graphic_image_io
+    graphic_surface
     graphic_texture_atlas
-    helper
     io_filesystem
-    io_stream
 )
 
 wl_library(graphic_color
@@ -32,7 +29,6 @@
   DEPENDS
     base_exceptions
     base_geometry
-    base_log
     base_macros
     graphic_color
     graphic_terrain_programs
@@ -128,6 +124,7 @@
 wl_library(graphic_draw_programs
   SRCS
     blend_mode.h
+    blit_mode.h
     gl/blit_program.cc
     gl/blit_program.h
     gl/draw_line_program.cc
@@ -244,10 +241,11 @@
     base_geometry
     base_i18n
     base_log
-    graphic_draw_programs
     base_macros
     build_info
+    graphic_build_texture_atlas
     graphic_color
+    graphic_draw_programs
     graphic_gl_utils
     graphic_image_cache
     graphic_image_io
 
=== added file 'src/graphic/blit_mode.h'
--- src/graphic/blit_mode.h	1970-01-01 00:00:00 +0000
+++ src/graphic/blit_mode.h	2016-01-16 20:47:43 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2006-2016 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 WL_GRAPHIC_BLIT_MODE_H
+#define WL_GRAPHIC_BLIT_MODE_H
+
+// The type of blit performed.
+enum class BlitMode {
+	// Blit texture unchanged.
+	kDirect,
+
+	// Blit texture desaturated and maybe tinted with a color.
+	kMonochrome,
+
+	// Blit texture tinted with a color everywhere where a mask is not
+	// transparent,
+	kBlendedWithMask,
+};
+
+#endif  // end of include guard: WL_GRAPHIC_BLIT_MODE_H
 
=== renamed file 'src/graphic/make_texture_atlas_main.cc' => 'src/graphic/build_texture_atlas.cc'
--- src/graphic/make_texture_atlas_main.cc	2016-01-12 21:26:15 +0000
+++ src/graphic/build_texture_atlas.cc	2016-01-16 20:47:43 +0000
@@ -17,29 +17,21 @@
  *
  */
 
-#include <fstream>
-#include <iostream>
+#include "graphic/build_texture_atlas.h"
+
+#include <map>
 #include <memory>
-#include <set>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
-#include <SDL.h>
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/format.hpp>
-
-#undef main // No, we do not want SDL_main
-
-#include "base/log.h"
-#include "config.h"
+
 #include "graphic/graphic.h"
 #include "graphic/image_io.h"
 #include "graphic/texture_atlas.h"
-#include "helper.h"
 #include "io/filesystem/filesystem.h"
 #include "io/filesystem/layered_filesystem.h"
-#include "io/streamwrite.h"
 
 namespace {
 
@@ -47,47 +39,10 @@
 // threshold, but not background pictures.
 constexpr int kMaxAreaForTextureAtlas = 240 * 240;
 
+// A graphics card must at least support this size for texture for Widelands to
+// run.
 constexpr int kMinimumSizeForTextures = 2048;
 
-// An image can either be Type::kPacked inside a texture atlas, in which case
-// we need to keep track which one and where inside of that one. It can also be
-// Type::kUnpacked if it is to be loaded from disk.
-struct PackInfo {
-	enum class Type {
-		kUnpacked,
-		kPacked,
-	};
-
-	Type type;
-	int texture_atlas;
-	Rect rect;
-};
-
-int parse_arguments(
-   int argc, char** argv, int* max_size)
-{
-	if (argc < 2) {
-		std::cout << "Usage: wl_make_texture_atlas [max_size]" << std::endl << std::endl
-		          << "Will write output.png in the current directory." << std::endl;
-		return 1;
-	}
-	*max_size = atoi(argv[1]);
-	if (*max_size < kMinimumSizeForTextures) {
-		std::cout << "Widelands requires at least 2048 for the smallest texture size." << std::endl;
-		return 1;
-	}
-	return 0;
-}
-
-// Setup the static objects Widelands needs to operate and initializes systems.
-void initialize() {
-	SDL_Init(SDL_INIT_VIDEO);
-
-	g_fs = new LayeredFileSystem();
-	g_fs->add_file_system(&FileSystem::create(INSTALL_DATADIR));
-	g_gr = new Graphic(1, 1, false);
-}
-
 // Returns true if 'filename' ends with an image extension.
 bool is_image(const std::string& filename) {
 	return boost::ends_with(filename, ".png") || boost::ends_with(filename, ".jpg");
@@ -113,68 +68,34 @@
 	}
 }
 
-void dump_result(const std::map<std::string, PackInfo>& pack_info,
-                 std::vector<std::unique_ptr<Texture>>* texture_atlases,
-                 FileSystem* fs) {
-
-	for (size_t i = 0; i < texture_atlases->size(); ++i) {
-		std::unique_ptr<StreamWrite> sw(
-		   fs->open_stream_write((boost::format("output_%02i.png") % i).str()));
-		save_to_png(texture_atlases->at(i).get(), sw.get(), ColorType::RGBA);
-	}
-
-	{
-		std::unique_ptr<StreamWrite> sw(fs->open_stream_write("output.lua"));
-		sw->text("return {\n");
-		for (const auto& pair : pack_info) {
-			sw->text("   [\"");
-			sw->text(pair.first);
-			sw->text("\"] = {\n");
-
-			switch (pair.second.type) {
-			case PackInfo::Type::kPacked:
-				sw->text("       type = \"packed\",\n");
-				sw->text(
-				   (boost::format("       texture_atlas = %d,\n") % pair.second.texture_atlas).str());
-				sw->text((boost::format("       rect = { %d, %d, %d, %d },\n") % pair.second.rect.x %
-				          pair.second.rect.y % pair.second.rect.w % pair.second.rect.h).str());
-				break;
-
-			case PackInfo::Type::kUnpacked:
-				sw->text("       type = \"unpacked\",\n");
-				break;
-			}
-			sw->text("   },\n");
-		}
-		sw->text("}\n");
-	}
+// If 'filename' should end up in the texture atlas, will load it into 'image'
+// and return true.
+bool should_be_packed(const std::string& filename, std::unique_ptr<Texture>* image) {
+	if (boost::ends_with(filename, ".jpg")) {
+		return false;
+	}
+	*image = load_image(filename, g_fs);
+	const auto area = (*image)->width() * (*image)->height();
+	if (area > kMaxAreaForTextureAtlas) {
+		return false;
+	}
+	return true;
 }
 
 // Pack the images in 'filenames' into texture atlases.
-std::vector<std::unique_ptr<Texture>> pack_images(const std::vector<std::string>& filenames,
-                                                  const int max_size,
-                                                  std::map<std::string, PackInfo>* pack_info,
-                                                  Texture* first_texture,
-																  TextureAtlas::PackedTexture* first_atlas_packed_texture) {
+std::vector<std::unique_ptr<Texture>>
+pack_images(const std::vector<std::string>& filenames,
+            const int max_size,
+            std::map<std::string, std::unique_ptr<Texture>>* textures_in_atlas) {
 	std::vector<std::pair<std::string, std::unique_ptr<Texture>>> to_be_packed;
 	for (const auto& filename : filenames) {
-		std::unique_ptr<Texture> image = load_image(filename, g_fs);
-		const auto area = image->width() * image->height();
-		if (area < kMaxAreaForTextureAtlas) {
+		std::unique_ptr<Texture> image;
+		if (should_be_packed(filename, &image)) {
 			to_be_packed.push_back(std::make_pair(filename, std::move(image)));
-		} else {
-			pack_info->insert(std::make_pair(filename, PackInfo{
-			                                              PackInfo::Type::kUnpacked, 0, Rect(),
-			                                           }));
 		}
 	}
 
 	TextureAtlas atlas;
-	int packed_texture_index = 0;
-	if (first_texture != nullptr) {
-		atlas.add(*first_texture);
-		packed_texture_index = 1;
-	}
 	for (auto& pair : to_be_packed) {
 		atlas.add(*pair.second);
 	}
@@ -183,92 +104,36 @@
 	std::vector<TextureAtlas::PackedTexture> packed_textures;
 	atlas.pack(max_size, &texture_atlases, &packed_textures);
 
-	if (first_texture != nullptr) {
-		assert(first_atlas_packed_texture != nullptr);
-		*first_atlas_packed_texture = std::move(packed_textures[0]);
-	}
-
 	for (size_t i = 0; i < to_be_packed.size(); ++i) {
-		const auto& packed_texture = packed_textures.at(packed_texture_index++);
-		pack_info->insert(
-		   std::make_pair(to_be_packed[i].first, PackInfo{PackInfo::Type::kPacked,
-		                                                  packed_texture.texture_atlas,
-		                                                  packed_texture.texture->blit_data().rect}));
+		textures_in_atlas->insert(
+		   std::make_pair(to_be_packed[i].first, std::move(packed_textures[i].texture)));
 	}
 	return texture_atlases;
 }
 
 }  // namespace
 
-int main(int argc, char** argv) {
-	int max_size;
-	if (parse_arguments(argc, argv, &max_size))
-		return 1;
-
-	if (SDL_Init(SDL_INIT_VIDEO) < 0) {
-		std::cerr << "SDLInit did not succeed: " << SDL_GetError() << std::endl;
-		return 1;
+std::vector<std::unique_ptr<Texture>>
+build_texture_atlas(const int max_size,
+                    std::map<std::string, std::unique_ptr<Texture>>* textures_in_atlas) {
+	if (max_size < kMinimumSizeForTextures) {
+		throw wexception("The texture atlas must use at least %d as size (%d was given)",
+		                 kMinimumSizeForTextures, max_size);
 	}
-	initialize();
-
-
-	// For performance reasons, we need to have some images in the first texture
-	// atlas, so that OpenGL texture switches do not happen during (for example)
-	// terrain or road rendering. To ensure this, we separate all images into
-	// two disjunct sets. We than pack all images that should go into the first
-	// texture atlas into a texture atlas. Then, we pack all remaining textures
-	// into a texture atlas, but including the first texture atlas as a singular
-	// image (which will probably be the biggest we allow).
-	//
-	// We have to adjust the sub rectangle rendering for the images in the first
-	// texture atlas in 'pack_info' later, before dumping the results.
-	std::vector<std::string> other_images, images_that_must_be_in_first_atlas;
+	std::vector<std::string> first_atlas_images;
 	std::unordered_set<std::string> all_images;
 
 	// For terrain textures.
-	find_images("world/terrains", &all_images, &images_that_must_be_in_first_atlas);
+	find_images("world/terrains", &all_images, &first_atlas_images);
 	// For flags and roads.
-	find_images("tribes/images", &all_images, &images_that_must_be_in_first_atlas);
+	find_images("tribes/images", &all_images, &first_atlas_images);
 	// For UI elements mostly, but we get more than we need really.
-	find_images("pics", &all_images, &images_that_must_be_in_first_atlas);
-
-	// Add all other images, we do not really cares about the order for these.
-	find_images("world", &all_images, &other_images);
-	find_images("tribes", &all_images, &other_images);
-	assert(images_that_must_be_in_first_atlas.size() + other_images.size() == all_images.size());
-
-	std::map<std::string, PackInfo> first_texture_atlas_pack_info;
-	auto first_texture_atlas = pack_images(images_that_must_be_in_first_atlas, max_size,
-	                                       &first_texture_atlas_pack_info, nullptr, nullptr);
+	find_images("pics", &all_images, &first_atlas_images);
+
+	auto first_texture_atlas = pack_images(first_atlas_images, max_size, textures_in_atlas);
 	if (first_texture_atlas.size() != 1) {
-		std::cout << "Not all images that should fit in the first texture atlas did actually fit."
-		          << std::endl;
-		return 1;
-	}
-
-	std::map<std::string, PackInfo> pack_info;
-	TextureAtlas::PackedTexture first_atlas_packed_texture;
-	auto texture_atlases = pack_images(other_images, max_size, &pack_info,
-	                                   first_texture_atlas[0].get(), &first_atlas_packed_texture);
-
-	const auto& blit_data = first_atlas_packed_texture.texture->blit_data();
-	for (const auto& pair : first_texture_atlas_pack_info) {
-		assert(pack_info.count(pair.first) == 0);
-		pack_info.insert(std::make_pair(pair.first, PackInfo{
-		                                               pair.second.type,
-		                                               first_atlas_packed_texture.texture_atlas,
-		                                               Rect(blit_data.rect.x + pair.second.rect.x,
-		                                                    blit_data.rect.y + pair.second.rect.y,
-		                                                    pair.second.rect.w, pair.second.rect.h),
-		                                            }));
-	}
-
-	// Make sure we have all images.
-	assert(all_images.size() == pack_info.size());
-
-	std::unique_ptr<FileSystem> output_fs(&FileSystem::create("."));
-	dump_result(pack_info, &texture_atlases, output_fs.get());
-
-	SDL_Quit();
-	return 0;
+		throw wexception("Not all images that should fit in the first texture atlas did actually "
+		                 "fit. Widelands has now more images than before.");
+	}
+	return {std::move(first_texture_atlas)};
 }
 
=== added file 'src/graphic/build_texture_atlas.h'
--- src/graphic/build_texture_atlas.h	1970-01-01 00:00:00 +0000
+++ src/graphic/build_texture_atlas.h	2016-01-16 20:47:43 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2006-2016 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 WL_GRAPHIC_BUILD_TEXTURE_ATLAS_H
+#define WL_GRAPHIC_BUILD_TEXTURE_ATLAS_H
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "graphic/texture.h"
+
+// Builds a texture atlas where no texture is bigger than 'max_size' x
+// 'max_size' using the most commonly used images like UI elements, roads and
+// textures. Returns the texture_atlases which must be kept around in memory
+// and fills in 'textures_in_atlas' which is a map from filename to Texture in
+// the atlas.
+std::vector<std::unique_ptr<Texture>>
+build_texture_atlas(
+		const int max_size, std::map<std::string, std::unique_ptr<Texture>>* textures_in_atlas);
+
+#endif  // end of include guard: WL_GRAPHIC_BUILD_TEXTURE_ATLAS_H
 
=== modified file 'src/graphic/font_handler1.cc'
--- src/graphic/font_handler1.cc	2016-01-04 20:54:08 +0000
+++ src/graphic/font_handler1.cc	2016-01-16 20:47:43 +0000
@@ -139,8 +139,8 @@
 	ImageCache* const image_cache_;  // not owned
 };
 
-IFontHandler1 * create_fonthandler(Graphic* gr) {
-	return new FontHandler1(&gr->images());
+IFontHandler1 * create_fonthandler(ImageCache* image_cache) {
+	return new FontHandler1(image_cache);
 }
 
 IFontHandler1 * g_fh1 = nullptr;
 
=== modified file 'src/graphic/font_handler1.h'
--- src/graphic/font_handler1.h	2014-12-06 09:07:19 +0000
+++ src/graphic/font_handler1.h	2016-01-16 20:47:43 +0000
@@ -32,7 +32,7 @@
 
 class FileSystem;
 class Image;
-class Graphic;
+class ImageCache;
 
 namespace UI {
 
@@ -61,8 +61,8 @@
 	DISALLOW_COPY_AND_ASSIGN(IFontHandler1);
 };
 
-// Create a new FontHandler1. Ownership for the objects is not taken.
-IFontHandler1 * create_fonthandler(Graphic* gr);
+// Create a new FontHandler1.
+IFontHandler1 * create_fonthandler(ImageCache* image_cache);
 
 extern IFontHandler1 * g_fh1;
 
 
=== modified file 'src/graphic/gl/blit_program.cc'
--- src/graphic/gl/blit_program.cc	2016-01-05 11:28:54 +0000
+++ src/graphic/gl/blit_program.cc	2016-01-16 20:47:43 +0000
@@ -22,6 +22,7 @@
 #include <vector>
 
 #include "base/log.h"
+#include "graphic/blit_mode.h"
 #include "graphic/gl/blit_data.h"
 #include "graphic/gl/coordinate_conversion.h"
 #include "graphic/gl/utils.h"
@@ -36,52 +37,23 @@
 attribute vec2 attr_texture_position;
 attribute vec3 attr_position;
 attribute vec4 attr_blend;
+attribute float attr_program_flavor;
 
 varying vec2 out_mask_texture_coordinate;
 varying vec2 out_texture_coordinate;
 varying vec4 out_blend;
+varying float out_program_flavor;
 
 void main() {
 	out_mask_texture_coordinate = attr_mask_texture_position;
 	out_texture_coordinate = attr_texture_position;
 	out_blend = attr_blend;
+	out_program_flavor = attr_program_flavor;
 	gl_Position = vec4(attr_position, 1.);
 }
 )";
 
-const char kVanillaBlitFragmentShader[] = R"(
-#version 120
-
-uniform sampler2D u_texture;
-
-varying vec2 out_texture_coordinate;
-varying vec4 out_blend;
-
-void main() {
-	vec4 color = texture2D(u_texture, out_texture_coordinate);
-	gl_FragColor = color * out_blend;
-}
-)";
-
-const char kMonochromeBlitFragmentShader[] = R"(
-#version 120
-
-uniform sampler2D u_texture;
-
-varying vec2 out_texture_coordinate;
-varying vec4 out_blend;
-
-void main() {
-	vec4 texture_color = texture2D(u_texture, out_texture_coordinate);
-
-	// See http://en.wikipedia.org/wiki/YUV.
-	float luminance = dot(vec3(0.299, 0.587, 0.114), texture_color.rgb);
-
-	gl_FragColor = vec4(vec3(luminance) * out_blend.rgb, out_blend.a * texture_color.a);
-}
-)";
-
-const char kBlendedBlitFragmentShader[] = R"(
+const char kBlitFragmentShader[] = R"(
 #version 120
 
 uniform sampler2D u_texture;
@@ -90,16 +62,25 @@
 varying vec2 out_mask_texture_coordinate;
 varying vec2 out_texture_coordinate;
 varying vec4 out_blend;
+varying float out_program_flavor;
 
 void main() {
 	vec4 texture_color = texture2D(u_texture, out_texture_coordinate);
-	vec4 mask_color = texture2D(u_mask, out_mask_texture_coordinate);
 
 	// See http://en.wikipedia.org/wiki/YUV.
 	float luminance = dot(vec3(0.299, 0.587, 0.114), texture_color.rgb);
-	float blend_influence = mask_color.r * mask_color.a;
-	gl_FragColor = vec4(
-		mix(texture_color.rgb, out_blend.rgb * luminance, blend_influence), out_blend.a * texture_color.a);
+
+	if (out_program_flavor == 0.) {
+		gl_FragColor = vec4(texture_color.rgb, out_blend.a * texture_color.a);
+	} else if (out_program_flavor == 1.) {
+		gl_FragColor = vec4(vec3(luminance) * out_blend.rgb, out_blend.a * texture_color.a);
+	} else {
+		vec4 mask_color = texture2D(u_mask, out_mask_texture_coordinate);
+		float blend_influence = mask_color.r * mask_color.a;
+		gl_FragColor = vec4(
+			mix(texture_color.rgb, out_blend.rgb * luminance, blend_influence),
+				out_blend.a * texture_color.a);
+	}
 }
 )";
 
@@ -117,104 +98,31 @@
 
 }  // namespace
 
-class BlitProgram {
-public:
-	struct Arguments {
-		FloatRect destination_rect;
-		float z_value;
-		BlitData texture;
-		BlitData mask;
-		RGBAColor blend;
-		BlendMode blend_mode;
-	};
-	BlitProgram(const std::string& fragment_shader);
-
-	void activate();
-
-	void draw_and_deactivate(const std::vector<Arguments>& arguments);
-
-	int program_object() const {
-		return gl_program_.object();
-	}
-
-private:
-	struct PerVertexData {
-		PerVertexData(float init_gl_x,
-		              float init_gl_y,
-		              float init_gl_z,
-		              float init_texture_x,
-		              float init_texture_y,
-		              float init_mask_texture_x,
-		              float init_mask_texture_y,
-		              float init_blend_r,
-		              float init_blend_g,
-		              float init_blend_b,
-		              float init_blend_a)
-		   : gl_x(init_gl_x),
-		     gl_y(init_gl_y),
-		     gl_z(init_gl_z),
-		     texture_x(init_texture_x),
-		     texture_y(init_texture_y),
-		     mask_texture_x(init_mask_texture_x),
-		     mask_texture_y(init_mask_texture_y),
-		     blend_r(init_blend_r),
-		     blend_g(init_blend_g),
-		     blend_b(init_blend_b),
-		     blend_a(init_blend_a) {
-		}
-
-		float gl_x, gl_y, gl_z;
-		float texture_x, texture_y;
-		float mask_texture_x, mask_texture_y;
-		float blend_r, blend_g, blend_b, blend_a;
-	};
-	static_assert(sizeof(PerVertexData) == 44, "Wrong padding.");
-
-	// The buffer that will contain the quad for rendering.
-	Gl::Buffer<PerVertexData> gl_array_buffer_;
-
-	// The program.
-	Gl::Program gl_program_;
-
-	// Attributes.
-	GLint attr_blend_;
-	GLint attr_mask_texture_position_;
-	GLint attr_position_;
-	GLint attr_texture_position_;
-
-	// Uniforms.
-	GLint u_texture_;
-	GLint u_mask_;
-
-	// Cached for efficiency.
-	std::vector<PerVertexData> vertices_;
-
-	DISALLOW_COPY_AND_ASSIGN(BlitProgram);
-};
-
-BlitProgram::BlitProgram(const std::string& fragment_shader) {
-	gl_program_.build(kBlitVertexShader, fragment_shader.c_str());
+BlitProgram::BlitProgram() {
+	gl_program_.build(kBlitVertexShader, kBlitFragmentShader);
 
 	attr_blend_ = glGetAttribLocation(gl_program_.object(), "attr_blend");
 	attr_mask_texture_position_ = glGetAttribLocation(gl_program_.object(), "attr_mask_texture_position");
 	attr_position_ = glGetAttribLocation(gl_program_.object(), "attr_position");
 	attr_texture_position_ = glGetAttribLocation(gl_program_.object(), "attr_texture_position");
+	attr_program_flavor_ = glGetAttribLocation(gl_program_.object(), "attr_program_flavor");
 
 	u_texture_ = glGetUniformLocation(gl_program_.object(), "u_texture");
 	u_mask_ = glGetUniformLocation(gl_program_.object(), "u_mask");
 }
 
-void BlitProgram::activate() {
+BlitProgram::~BlitProgram() {}
+
+void BlitProgram::draw(const std::vector<Arguments>& arguments) {
 	glUseProgram(gl_program_.object());
 
-	glEnableVertexAttribArray(attr_blend_);
-	glEnableVertexAttribArray(attr_mask_texture_position_);
-	glEnableVertexAttribArray(attr_position_);
-	glEnableVertexAttribArray(attr_texture_position_);
-}
+	auto& gl_state = Gl::State::instance();
 
-void BlitProgram::draw_and_deactivate(const std::vector<Arguments>& arguments) {
-	size_t i = 0;
+	gl_state.enable_vertex_attrib_array({attr_blend_,
+	                                   attr_mask_texture_position_,
+	                                   attr_position_,
+	                                   attr_texture_position_,
+	                                   attr_program_flavor_});
 
 	gl_array_buffer_.bind();
 
@@ -226,6 +134,8 @@
 	Gl::vertex_attrib_pointer(attr_position_, 3, sizeof(PerVertexData), offsetof(PerVertexData, gl_x));
 	Gl::vertex_attrib_pointer(
 	   attr_texture_position_, 2, sizeof(PerVertexData), offsetof(PerVertexData, texture_x));
+	Gl::vertex_attrib_pointer(
+	   attr_program_flavor_, 1, sizeof(PerVertexData), offsetof(PerVertexData, program_flavor));
 
 	glUniform1i(u_texture_, 0);
 	glUniform1i(u_mask_, 1);
@@ -234,15 +144,18 @@
 	std::vector<DrawBatch> draw_batches;
 	int offset = 0;
 	vertices_.clear();
+
+	size_t i = 0;
 	while (i < arguments.size()) {
-		const Arguments& template_args = arguments[i];
+		const auto& template_args = arguments[i];
 
 		// Batch common blit operations up.
 		while (i < arguments.size()) {
-			const Arguments& current_args = arguments[i];
+			const auto& current_args = arguments[i];
 			if (current_args.blend_mode != template_args.blend_mode ||
-					current_args.texture.texture_id != template_args.texture.texture_id ||
-					current_args.mask.texture_id != template_args.mask.texture_id) {
+			    current_args.texture.texture_id != template_args.texture.texture_id ||
+			    (current_args.mask.texture_id != 0 &&
+			     current_args.mask.texture_id != template_args.mask.texture_id)) {
 				break;
 			}
 
@@ -253,56 +166,71 @@
 
 			const FloatRect texture_rect = to_gl_texture(current_args.texture);
 			const FloatRect mask_rect = to_gl_texture(current_args.mask);
-			vertices_.emplace_back(current_args.destination_rect.x,
-					current_args.destination_rect.y,
-					current_args.z_value,
-					texture_rect.x,
-					texture_rect.y,
-					mask_rect.x,
-					mask_rect.y,
-					blend_r,
-					blend_g,
-					blend_b,
-					blend_a);
-
-			vertices_.emplace_back(current_args.destination_rect.x + current_args.destination_rect.w,
-					current_args.destination_rect.y,
-					current_args.z_value,
-					texture_rect.x + texture_rect.w,
-					texture_rect.y,
-					mask_rect.x + mask_rect.w,
-					mask_rect.y,
-					blend_r,
-					blend_g,
-					blend_b,
-					blend_a);
-
-			vertices_.emplace_back(current_args.destination_rect.x,
-					current_args.destination_rect.y + current_args.destination_rect.h,
-					current_args.z_value,
-					texture_rect.x,
-					texture_rect.y + texture_rect.h,
-					mask_rect.x,
-					mask_rect.y + mask_rect.h,
-					blend_r,
-					blend_g,
-					blend_b,
-					blend_a);
-
-			vertices_.emplace_back(vertices_.at(vertices_.size() - 2));
-			vertices_.emplace_back(vertices_.at(vertices_.size() - 2));
-
-			vertices_.emplace_back(current_args.destination_rect.x + current_args.destination_rect.w,
-					current_args.destination_rect.y + current_args.destination_rect.h,
-					current_args.z_value,
-					texture_rect.x + texture_rect.w,
-					texture_rect.y + texture_rect.h,
-					mask_rect.x + mask_rect.w,
-					mask_rect.y + mask_rect.h,
-					blend_r,
-					blend_g,
-					blend_b,
-					blend_a);
+			float program_flavor = 0;
+			switch (current_args.blit_mode) {
+				case BlitMode::kDirect:
+					program_flavor = 0.;
+					break;
+
+				case BlitMode::kMonochrome:
+					program_flavor = 1.;
+					break;
+
+				case BlitMode::kBlendedWithMask:
+					program_flavor = 2.;
+					break;
+			}
+
+			vertices_.emplace_back(current_args.destination_rect.x,
+					current_args.destination_rect.y,
+					current_args.z_value,
+					texture_rect.x,
+					texture_rect.y,
+					mask_rect.x,
+					mask_rect.y,
+					blend_r,
+					blend_g,
+					blend_b,
+					blend_a, program_flavor);
+
+			vertices_.emplace_back(current_args.destination_rect.x + current_args.destination_rect.w,
+					current_args.destination_rect.y,
+					current_args.z_value,
+					texture_rect.x + texture_rect.w,
+					texture_rect.y,
+					mask_rect.x + mask_rect.w,
+					mask_rect.y,
+					blend_r,
+					blend_g,
+					blend_b,
+					blend_a, program_flavor);
+
+			vertices_.emplace_back(current_args.destination_rect.x,
+					current_args.destination_rect.y + current_args.destination_rect.h,
+					current_args.z_value,
+					texture_rect.x,
+					texture_rect.y + texture_rect.h,
+					mask_rect.x,
+					mask_rect.y + mask_rect.h,
+					blend_r,
+					blend_g,
+					blend_b,
+					blend_a, program_flavor);
+
+			vertices_.emplace_back(vertices_.at(vertices_.size() - 2));
+			vertices_.emplace_back(vertices_.at(vertices_.size() - 2));
+
+			vertices_.emplace_back(current_args.destination_rect.x + current_args.destination_rect.w,
+					current_args.destination_rect.y + current_args.destination_rect.h,
+					current_args.z_value,
+					texture_rect.x + texture_rect.w,
+					texture_rect.y + texture_rect.h,
+					mask_rect.x + mask_rect.w,
+					mask_rect.y + mask_rect.h,
+					blend_r,
+					blend_g,
+					blend_b,
+					blend_a, program_flavor);
 			++i;
 		}
 
@@ -317,11 +245,8 @@
 
 	// Now do the draw calls.
 	for (const auto& draw_arg : draw_batches) {
-		glActiveTexture(GL_TEXTURE0);
-		glBindTexture(GL_TEXTURE_2D, draw_arg.texture);
-
-		glActiveTexture(GL_TEXTURE1);
-		glBindTexture(GL_TEXTURE_2D, draw_arg.mask);
+		gl_state.bind(GL_TEXTURE0, draw_arg.texture);
+		gl_state.bind(GL_TEXTURE1, draw_arg.mask);
 
 		if (draw_arg.blend_mode == BlendMode::Copy) {
 			glBlendFunc(GL_ONE, GL_ZERO);
@@ -332,130 +257,38 @@
 			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 		}
 	}
-
-	glDisableVertexAttribArray(attr_blend_);
-	glDisableVertexAttribArray(attr_mask_texture_position_);
-	glDisableVertexAttribArray(attr_position_);
-	glDisableVertexAttribArray(attr_texture_position_);
-
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-// static
-VanillaBlitProgram& VanillaBlitProgram::instance() {
-	static VanillaBlitProgram blit_program;
-	return blit_program;
-}
-
-VanillaBlitProgram::~VanillaBlitProgram() {
-}
-
-VanillaBlitProgram::VanillaBlitProgram() {
-	blit_program_.reset(new BlitProgram(kVanillaBlitFragmentShader));
-}
-
-void VanillaBlitProgram::draw(const FloatRect& gl_dest_rect,
+}
+
+void BlitProgram::draw(const FloatRect& gl_dest_rect,
                               const float z_value,
 										const BlitData& texture,
-                              const float opacity,
-                              const BlendMode blend_mode) {
-	draw({Arguments{gl_dest_rect, z_value, texture, opacity, blend_mode}});
-}
-
-void VanillaBlitProgram::draw(const std::vector<Arguments>& arguments) {
-	std::vector<BlitProgram::Arguments> blit_arguments;
-	for (const Arguments arg : arguments) {
-		blit_arguments.emplace_back(BlitProgram::Arguments{
-		   arg.destination_rect,
-		   arg.z_value,
-		   arg.texture,
-		   BlitData{0, 0, 0, Rect()},
-		   RGBAColor(255, 255, 255, arg.opacity * 255),
-		   arg.blend_mode,
-		});
-	}
-
-	blit_program_->activate();
-	blit_program_->draw_and_deactivate(blit_arguments);
-}
-
-
-// static
-MonochromeBlitProgram& MonochromeBlitProgram::instance() {
-	static MonochromeBlitProgram blit_program;
-	return blit_program;
-}
-
-MonochromeBlitProgram::~MonochromeBlitProgram() {
-}
-
-MonochromeBlitProgram::MonochromeBlitProgram() {
-	blit_program_.reset(new BlitProgram(kMonochromeBlitFragmentShader));
-}
-
-void MonochromeBlitProgram::draw(const FloatRect& dest_rect,
+										const BlitData& mask,
+                              const RGBAColor& blend,
+										const BlendMode& blend_mode) {
+	draw({Arguments{gl_dest_rect,
+	                z_value,
+	                texture,
+	                mask,
+	                blend,
+	                blend_mode,
+	                mask.texture_id != 0 ? BlitMode::kBlendedWithMask : BlitMode::kDirect}});
+}
+
+void BlitProgram::draw_monochrome(const FloatRect& dest_rect,
                                  const float z_value,
 											const BlitData& texture,
                                  const RGBAColor& blend) {
-	draw({Arguments{dest_rect, z_value, texture, blend, BlendMode::UseAlpha}});
-}
-
-void MonochromeBlitProgram::draw(const std::vector<Arguments>& arguments) {
-	std::vector<BlitProgram::Arguments> blit_arguments;
-	for (const Arguments arg : arguments) {
-		blit_arguments.emplace_back(BlitProgram::Arguments{
-		   arg.destination_rect,
-		   arg.z_value,
-		   arg.texture,
-		   BlitData{0, 0, 0, Rect()},
-		   arg.blend,
-		   arg.blend_mode,
-		});
-	}
-
-	blit_program_->activate();
-	blit_program_->draw_and_deactivate(blit_arguments);
+	draw({Arguments{dest_rect,
+	                z_value,
+	                texture,
+	                BlitData{0, 0, 0, Rect()},
+	                blend,
+	                BlendMode::UseAlpha,
+	                BlitMode::kMonochrome}});
 }
 
 // static
-BlendedBlitProgram& BlendedBlitProgram::instance() {
-	static BlendedBlitProgram blit_program;
+BlitProgram& BlitProgram::instance() {
+	static BlitProgram blit_program;
 	return blit_program;
 }
-
-BlendedBlitProgram::~BlendedBlitProgram() {
-}
-
-BlendedBlitProgram::BlendedBlitProgram() {
-	blit_program_.reset(new BlitProgram(kBlendedBlitFragmentShader));
-}
-
-void BlendedBlitProgram::draw(const FloatRect& gl_dest_rect,
-                              const float z_value,
-										const BlitData& texture,
-										const BlitData& mask,
-                              const RGBAColor& blend) {
-	draw({Arguments{gl_dest_rect, z_value, texture, mask, blend, BlendMode::UseAlpha}});
-}
-
-void BlendedBlitProgram::draw(const std::vector<Arguments>& arguments) {
-	std::vector<BlitProgram::Arguments> blit_arguments;
-	for (const Arguments arg : arguments) {
-		blit_arguments.emplace_back(BlitProgram::Arguments{
-		   arg.destination_rect,
-		   arg.z_value,
-		   arg.texture,
-			arg.mask,
-		   arg.blend,
-		   arg.blend_mode,
-		});
-	}
-
-	blit_program_->activate();
-	blit_program_->draw_and_deactivate(blit_arguments);
-}
 
=== modified file 'src/graphic/gl/blit_program.h'
--- src/graphic/gl/blit_program.h	2016-01-04 20:54:08 +0000
+++ src/graphic/gl/blit_program.h	2016-01-16 20:47:43 +0000
@@ -26,84 +26,14 @@
 #include "base/macros.h"
 #include "base/rect.h"
 #include "graphic/blend_mode.h"
+#include "graphic/blit_mode.h"
 #include "graphic/color.h"
 #include "graphic/gl/blit_data.h"
 #include "graphic/gl/system_headers.h"
-
-class BlitProgram;
-
-
-class VanillaBlitProgram {
-public:
-	struct Arguments {
-		FloatRect destination_rect;
-		float z_value;
-		BlitData texture;
-		float opacity;
-		BlendMode blend_mode;
-	};
-
-	// Returns the (singleton) instance of this class.
-	static VanillaBlitProgram& instance();
-	~VanillaBlitProgram();
-
-	// Draws the rectangle 'gl_src_rect' from the texture with the name
-	// 'texture' to 'gl_dest_rect' in the currently bound framebuffer. All alpha
-	// values are multiplied by 'opacity' during the blit.
-	// All coordinates are in the OpenGL frame. The 'blend_mode' defines if the
-	// values are copied or if alpha values are used.
-	void draw(const FloatRect& gl_dest_rect,
-				 const float z_value,
-				 const BlitData& texture,
-				 float opacity,
-	          const BlendMode blend_mode);
-
-	// Draws a bunch of items at once.
-	void draw(const std::vector<Arguments>& arguments);
-
-private:
-	VanillaBlitProgram();
-
-	std::unique_ptr<BlitProgram> blit_program_;
-
-	DISALLOW_COPY_AND_ASSIGN(VanillaBlitProgram);
-};
-
-class MonochromeBlitProgram {
-public:
-	struct Arguments {
-		FloatRect destination_rect;
-		float z_value;
-		BlitData texture;
-		RGBAColor blend;
-		BlendMode blend_mode;
-	};
-
-	// Returns the (singleton) instance of this class.
-	static MonochromeBlitProgram& instance();
-	~MonochromeBlitProgram();
-
-	// Draws the rectangle 'gl_src_rect' from the texture with the name
-	// 'texture' to 'gl_dest_rect' in the currently bound framebuffer. All
-	// coordinates are in the OpenGL frame. The image is first converted to
-	// luminance, then all values are multiplied with blend.
-	void draw(const FloatRect& gl_dest_rect,
-				 const float z_value,
-				 const BlitData& blit_source,
-				 const RGBAColor& blend);
-
-	// Draws a bunch of items at once.
-	void draw(const std::vector<Arguments>& arguments);
-
-private:
-	MonochromeBlitProgram();
-
-	std::unique_ptr<BlitProgram> blit_program_;
-
-	DISALLOW_COPY_AND_ASSIGN(MonochromeBlitProgram);
-};
-
-class BlendedBlitProgram {
+#include "graphic/gl/utils.h"
+
+// Blits images. Can blend them with player color or make them monochrome.
+class BlitProgram {
 public:
 	struct Arguments {
 		FloatRect destination_rect;
@@ -112,11 +42,12 @@
 		BlitData mask;
 		RGBAColor blend;
 		BlendMode blend_mode;
+		BlitMode blit_mode;
 	};
 
 	// Returns the (singleton) instance of this class.
-	static BlendedBlitProgram& instance();
-	~BlendedBlitProgram();
+	static BlitProgram& instance();
+	~BlitProgram();
 
 	// Draws the rectangle 'gl_src_rect' from the texture with the name
 	// 'gl_texture_image' to 'gl_dest_rect' in the currently bound framebuffer. All
@@ -126,17 +57,81 @@
 	          const float z_value,
 				 const BlitData& texture,
 				 const BlitData& mask,
-	          const RGBAColor& blend);
+	          const RGBAColor& blend,
+				 const BlendMode& blend_mode);
+
+	// Draws the rectangle 'gl_src_rect' from the texture with the name
+	// 'texture' to 'gl_dest_rect' in the currently bound framebuffer. All
+	// coordinates are in the OpenGL frame. The image is first converted to
+	// luminance, then all values are multiplied with blend.
+	void draw_monochrome(const FloatRect& gl_dest_rect,
+				 const float z_value,
+				 const BlitData& blit_source,
+				 const RGBAColor& blend);
+
 
 	// Draws a bunch of items at once.
 	void draw(const std::vector<Arguments>& arguments);
 
 private:
-	BlendedBlitProgram();
-
-	std::unique_ptr<BlitProgram> blit_program_;
-
-	DISALLOW_COPY_AND_ASSIGN(BlendedBlitProgram);
+	BlitProgram();
+
+	struct PerVertexData {
+		PerVertexData(float init_gl_x,
+		              float init_gl_y,
+		              float init_gl_z,
+		              float init_texture_x,
+		              float init_texture_y,
+		              float init_mask_texture_x,
+		              float init_mask_texture_y,
+		              float init_blend_r,
+		              float init_blend_g,
+		              float init_blend_b,
+		              float init_blend_a,
+		              float init_program_flavor)
+		   : gl_x(init_gl_x),
+		     gl_y(init_gl_y),
+		     gl_z(init_gl_z),
+		     texture_x(init_texture_x),
+		     texture_y(init_texture_y),
+		     mask_texture_x(init_mask_texture_x),
+		     mask_texture_y(init_mask_texture_y),
+		     blend_r(init_blend_r),
+		     blend_g(init_blend_g),
+		     blend_b(init_blend_b),
+		     blend_a(init_blend_a),
+		     program_flavor(init_program_flavor) {
+		}
+
+		float gl_x, gl_y, gl_z;
+		float texture_x, texture_y;
+		float mask_texture_x, mask_texture_y;
+		float blend_r, blend_g, blend_b, blend_a;
+		float program_flavor;
+	};
+	static_assert(sizeof(PerVertexData) == 48, "Wrong padding.");
+
+	// The buffer that will contain the quad for rendering.
+	Gl::Buffer<PerVertexData> gl_array_buffer_;
+
+	// The program.
+	Gl::Program gl_program_;
+
+	// Attributes.
+	GLint attr_blend_;
+	GLint attr_mask_texture_position_;
+	GLint attr_position_;
+	GLint attr_texture_position_;
+	GLint attr_program_flavor_;
+
+	// Uniforms.
+	GLint u_texture_;
+	GLint u_mask_;
+
+	// Cached for efficiency.
+	std::vector<PerVertexData> vertices_;
+
+	DISALLOW_COPY_AND_ASSIGN(BlitProgram);
 };
 
 #endif  // end of include guard: WL_GRAPHIC_GL_BLIT_PROGRAM_H
 
=== modified file 'src/graphic/gl/dither_program.cc'
--- src/graphic/gl/dither_program.cc	2016-01-05 11:28:54 +0000
+++ src/graphic/gl/dither_program.cc	2016-01-16 20:47:43 +0000
@@ -22,6 +22,7 @@
 #include "base/wexception.h"
 #include "graphic/gl/coordinate_conversion.h"
 #include "graphic/gl/fields_to_draw.h"
+#include "graphic/gl/utils.h"
 #include "graphic/image_io.h"
 #include "graphic/texture.h"
 #include "io/filesystem/layered_filesystem.h"
@@ -100,12 +101,11 @@
 
 	dither_mask_.reset(new Texture(load_image_as_sdl_surface("world/pics/edge.png", g_fs), true));
 
-	glBindTexture(GL_TEXTURE_2D, dither_mask_->blit_data().texture_id);
+	Gl::State::instance().bind(GL_TEXTURE0, dither_mask_->blit_data().texture_id);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, static_cast<GLint>(GL_CLAMP_TO_EDGE));
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, static_cast<GLint>(GL_CLAMP_TO_EDGE));
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(GL_LINEAR));
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(GL_NEAREST));
-	glBindTexture(GL_TEXTURE_2D, 0);
 }
 
 DitherProgram::~DitherProgram() {}
@@ -169,11 +169,12 @@
 void DitherProgram::gl_draw(int gl_texture, float texture_w, float texture_h, const float z_value) {
 	glUseProgram(gl_program_.object());
 
-	glEnableVertexAttribArray(attr_brightness_);
-	glEnableVertexAttribArray(attr_dither_texture_position_);
-	glEnableVertexAttribArray(attr_position_);
-	glEnableVertexAttribArray(attr_texture_offset_);
-	glEnableVertexAttribArray(attr_texture_position_);
+	auto& gl_state = Gl::State::instance();
+	gl_state.enable_vertex_attrib_array({attr_brightness_,
+	                                   attr_dither_texture_position_,
+	                                   attr_position_,
+	                                   attr_texture_offset_,
+	                                   attr_texture_position_});
 
 	gl_array_buffer_.bind();
 	gl_array_buffer_.update(vertices_);
@@ -190,14 +191,8 @@
 	Gl::vertex_attrib_pointer(
 	   attr_texture_position_, 2, sizeof(PerVertexData), offsetof(PerVertexData, texture_x));
 
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-	// Set the sampler texture unit to 0
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, dither_mask_->blit_data().texture_id);
-
-	glActiveTexture(GL_TEXTURE1);
-	glBindTexture(GL_TEXTURE_2D, gl_texture);
+	gl_state.bind(GL_TEXTURE0, dither_mask_->blit_data().texture_id);
+	gl_state.bind(GL_TEXTURE1, gl_texture);
 
 	glUniform1f(u_z_value_, z_value);
 	glUniform1i(u_dither_texture_, 0);
@@ -205,16 +200,6 @@
 	glUniform2f(u_texture_dimensions_, texture_w, texture_h);
 
 	glDrawArrays(GL_TRIANGLES, 0, vertices_.size());
-
-	glBindTexture(GL_TEXTURE_2D, 0);
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glDisableVertexAttribArray(attr_brightness_);
-	glDisableVertexAttribArray(attr_dither_texture_position_);
-	glDisableVertexAttribArray(attr_position_);
-	glDisableVertexAttribArray(attr_texture_offset_);
-	glDisableVertexAttribArray(attr_texture_position_);
 }
 
 void DitherProgram::draw(const uint32_t gametime,
 
=== modified file 'src/graphic/gl/draw_line_program.cc'
--- src/graphic/gl/draw_line_program.cc	2015-03-01 09:23:10 +0000
+++ src/graphic/gl/draw_line_program.cc	2016-01-16 20:47:43 +0000
@@ -89,8 +89,11 @@
 	size_t i = 0;
 
 	glUseProgram(gl_program_.object());
-	glEnableVertexAttribArray(attr_position_);
-	glEnableVertexAttribArray(attr_color_);
+
+	auto& gl_state = Gl::State::instance();
+	gl_state.enable_vertex_attrib_array({
+	   attr_position_, attr_color_,
+	});
 
 	gl_array_buffer_.bind();
 
@@ -140,11 +143,4 @@
 		glLineWidth(draw_arg.line_width);
 		glDrawArrays(GL_LINES, draw_arg.offset, draw_arg.count);
 	}
-
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-	glDisableVertexAttribArray(attr_position_);
-	glDisableVertexAttribArray(attr_color_);
-
-	glUseProgram(0);
 }
 
=== modified file 'src/graphic/gl/fill_rect_program.cc'
--- src/graphic/gl/fill_rect_program.cc	2015-03-01 09:23:10 +0000
+++ src/graphic/gl/fill_rect_program.cc	2016-01-16 20:47:43 +0000
@@ -112,8 +112,10 @@
 
 		gl_array_buffer_.bind();
 
-		glEnableVertexAttribArray(attr_position_);
-		glEnableVertexAttribArray(attr_color_);
+		auto& gl_state = Gl::State::instance();
+		gl_state.enable_vertex_attrib_array({
+		   attr_position_, attr_color_,
+		});
 
 		// Batch common rectangles up.
 		while (i < arguments.size()) {
@@ -199,8 +201,4 @@
 			break;
 		}
 	}
-
-	glDisableVertexAttribArray(attr_position_);
-	glDisableVertexAttribArray(attr_color_);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
 
=== modified file 'src/graphic/gl/road_program.cc'
--- src/graphic/gl/road_program.cc	2016-01-04 20:54:08 +0000
+++ src/graphic/gl/road_program.cc	2016-01-16 20:47:43 +0000
@@ -25,6 +25,7 @@
 #include "base/log.h"
 #include "graphic/gl/coordinate_conversion.h"
 #include "graphic/gl/fields_to_draw.h"
+#include "graphic/gl/utils.h"
 #include "graphic/graphic.h"
 #include "graphic/image_io.h"
 #include "graphic/texture.h"
@@ -111,7 +112,7 @@
 	const float road_thickness_x = (-delta_y / vector_length) * kRoadThicknessInPixels;
 	const float road_thickness_y = (delta_x / vector_length) * kRoadThicknessInPixels;
 
-	const Texture& texture =
+	const Image& texture =
 	   road_type == Widelands::RoadType::kNormal ?
 	      start.road_textures->get_normal_texture(start.fx, start.fy, direction) :
 	      start.road_textures->get_busy_texture(start.fx, start.fy, direction);
@@ -234,9 +235,10 @@
 
 	glUseProgram(gl_program_.object());
 
-	glEnableVertexAttribArray(attr_position_);
-	glEnableVertexAttribArray(attr_texture_position_);
-	glEnableVertexAttribArray(attr_brightness_);
+	auto& gl_state = Gl::State::instance();
+	gl_state.enable_vertex_attrib_array({
+		attr_position_, attr_texture_position_, attr_brightness_
+	});
 
 	gl_array_buffer_.bind();
 	gl_array_buffer_.update(vertices_);
@@ -248,19 +250,9 @@
 	Gl::vertex_attrib_pointer(
 	   attr_brightness_, 1, sizeof(PerVertexData), offsetof(PerVertexData, brightness));
 
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-	// Bind the textures.
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, gl_texture);
-
+	gl_state.bind(GL_TEXTURE0, gl_texture);
 	glUniform1i(u_texture_, 0);
-
 	glUniform1f(u_z_value_, z_value);
 
 	glDrawArrays(GL_TRIANGLES, 0, vertices_.size());
-
-	glDisableVertexAttribArray(attr_position_);
-	glDisableVertexAttribArray(attr_texture_position_);
-	glDisableVertexAttribArray(attr_brightness_);
 }
 
=== modified file 'src/graphic/gl/terrain_program.cc'
--- src/graphic/gl/terrain_program.cc	2016-01-04 20:54:08 +0000
+++ src/graphic/gl/terrain_program.cc	2016-01-16 20:47:43 +0000
@@ -21,6 +21,7 @@
 
 #include "graphic/gl/coordinate_conversion.h"
 #include "graphic/gl/fields_to_draw.h"
+#include "graphic/gl/utils.h"
 #include "graphic/texture.h"
 
 namespace  {
@@ -103,10 +104,9 @@
 void TerrainProgram::gl_draw(int gl_texture, float texture_w, float texture_h, float z_value) {
 	glUseProgram(gl_program_.object());
 
-	glEnableVertexAttribArray(attr_brightness_);
-	glEnableVertexAttribArray(attr_position_);
-	glEnableVertexAttribArray(attr_texture_offset_);
-	glEnableVertexAttribArray(attr_texture_position_);
+	auto& gl_state = Gl::State::instance();
+	gl_state.enable_vertex_attrib_array(
+		{attr_brightness_, attr_position_, attr_texture_offset_, attr_texture_position_});
 
 	gl_array_buffer_.bind();
 	gl_array_buffer_.update(vertices_);
@@ -119,23 +119,13 @@
 	Gl::vertex_attrib_pointer(
 	   attr_texture_position_, 2, sizeof(PerVertexData), offsetof(PerVertexData, texture_x));
 
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, gl_texture);
+	gl_state.bind(GL_TEXTURE0, gl_texture);
 
 	glUniform1f(u_z_value_, z_value);
 	glUniform1i(u_terrain_texture_, 0);
 	glUniform2f(u_texture_dimensions_, texture_w, texture_h);
 
 	glDrawArrays(GL_TRIANGLES, 0, vertices_.size());
-
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glDisableVertexAttribArray(attr_brightness_);
-	glDisableVertexAttribArray(attr_position_);
-	glDisableVertexAttribArray(attr_texture_offset_);
-	glDisableVertexAttribArray(attr_texture_position_);
 }
 
 void TerrainProgram::add_vertex(const FieldsToDraw::Field& field,
 
=== modified file 'src/graphic/gl/utils.cc'
--- src/graphic/gl/utils.cc	2015-02-20 07:45:49 +0000
+++ src/graphic/gl/utils.cc	2016-01-16 20:47:43 +0000
@@ -166,6 +166,78 @@
 	}
 }
 
+State::State()
+   : last_active_texture_(0), current_framebuffer_(0), current_framebuffer_texture_(0) {
+}
+
+void State::bind(const GLenum target, const GLuint texture) {
+	if (texture == 0)  {
+		return;
+	}
+	do_bind(target, texture);
+}
+
+void State::do_bind(const GLenum target, const GLuint texture) {
+	const auto currently_bound_texture = target_to_texture_[target];
+	if (currently_bound_texture == texture) {
+		return;
+	}
+	if (last_active_texture_ != target) {
+		glActiveTexture(target);
+		last_active_texture_ = target;
+	}
+	glBindTexture(GL_TEXTURE_2D, texture);
+
+	target_to_texture_[target] = texture;
+	texture_to_target_[currently_bound_texture] = 0;
+	texture_to_target_[texture] = target;
+}
+
+void State::unbind_texture_if_bound(const GLuint texture) {
+	if (texture == 0) {
+		return;
+	}
+	const auto target = texture_to_target_[texture];
+	if (target != 0) {
+		do_bind(target, 0);
+	}
+}
+
+void State::bind_framebuffer(const GLuint framebuffer, const GLuint texture) {
+	if (current_framebuffer_ == framebuffer && current_framebuffer_texture_ == texture) {
+		return;
+	}
+
+	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
+	if (framebuffer != 0) {
+		unbind_texture_if_bound(texture);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
+	}
+	current_framebuffer_ = framebuffer;
+	current_framebuffer_texture_ = texture;
+}
+
+void State::enable_vertex_attrib_array(std::unordered_set<GLint> entries) {
+	for (const auto e : entries) {
+		if (!enabled_attrib_arrays_.count(e)) {
+			glEnableVertexAttribArray(e);
+		}
+	}
+	for (const auto e : enabled_attrib_arrays_) {
+		if (!entries.count(e)) {
+			glDisableVertexAttribArray(e);
+		}
+	}
+	enabled_attrib_arrays_ = entries;
+}
+
+// static
+State& State::instance() {
+	static State binder;
+	return binder;
+}
+
+
 void vertex_attrib_pointer(int vertex_index, int num_items, int stride, int offset) {
 	glVertexAttribPointer(
 	   vertex_index, num_items, GL_FLOAT, GL_FALSE, stride, reinterpret_cast<void*>(offset));
 
=== modified file 'src/graphic/gl/utils.h'
--- src/graphic/gl/utils.h	2016-01-05 11:28:54 +0000
+++ src/graphic/gl/utils.h	2016-01-16 20:47:43 +0000
@@ -20,6 +20,8 @@
 #define WL_GRAPHIC_GL_UTILS_H
 
 #include <memory>
+#include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 #include <stdint.h>
@@ -63,10 +65,10 @@
 template<typename T>
 class Buffer {
 public:
-	Buffer() : buffer_size_(0) {
+	Buffer() {
 		glGenBuffers(1, &object_);
 		if (!object_) {
-			throw wexception("Could not create GL program.");
+			throw wexception("Could not create GL buffer.");
 		}
 	}
 
@@ -82,24 +84,60 @@
 	}
 
 
-	// Copies 'elements' into the buffer. If the buffer is too small to hold the
-	// data, it is reallocated. Does not check if the buffer is already bound.
+	// Copies 'elements' into the buffer, overwriting what was there before.
+	// Does not check if the buffer is already bound.
 	void update(const std::vector<T>& items) {
-		if (buffer_size_ < items.size()) {
-			glBufferData(GL_ARRAY_BUFFER, items.size() * sizeof(T), items.data(), GL_DYNAMIC_DRAW);
-			buffer_size_ = items.size();
-		} else {
-			glBufferSubData(GL_ARRAY_BUFFER, 0, items.size() * sizeof(T), items.data());
-		}
+		// Always re-allocate the buffer. This ends up being much more
+		// efficient than trying to do a partial update, because partial
+		// updates tend to force the driver to do command buffer flushes.
+		glBufferData(GL_ARRAY_BUFFER, items.size() * sizeof(T), items.data(), GL_DYNAMIC_DRAW);
 	}
 
 private:
 	GLuint object_;
-	size_t buffer_size_;  // In number of elements.
 
 	DISALLOW_COPY_AND_ASSIGN(Buffer);
 };
 
+// Some GL drivers do not remember the current pipeline state. If you rebind a
+// texture that has already bound to the same target, they will happily stall
+// the pipeline. We therefore cache the state of the GL driver in this class
+// and skip unneeded GL calls.
+class State {
+public:
+	static State& instance();
+
+	void bind_framebuffer(GLuint framebuffer, GLuint texture);
+
+	// Wrapper around glActiveTexture() and glBindTexture(). We never unbind a
+	// texture, i.e. calls with texture == 0 are ignored. It costs only time and
+	// is only needed when the bounded texture is rendered on - see
+	// 'unbind_texture_if_bound'.
+	void bind(GLenum target, GLuint texture);
+
+	// Checks if the texture is bound to any target. If so, unbinds it. This is
+	// needed before the texture is used as target for rendering.
+	void unbind_texture_if_bound(GLuint texture);
+
+	// Calls glEnableVertexAttribArray on all 'entries' and disables all others
+	// that are activated. 'entries' is taken by value on purpose.
+	void enable_vertex_attrib_array(std::unordered_set<GLint> entries);
+
+private:
+	std::unordered_map<GLenum, GLuint> target_to_texture_;
+	std::unordered_map<GLuint, GLenum> texture_to_target_;
+	std::unordered_set<GLint> enabled_attrib_arrays_;
+	GLenum last_active_texture_;
+	GLuint current_framebuffer_;
+	GLuint current_framebuffer_texture_;
+
+	State();
+
+	void do_bind(GLenum target, GLuint texture);
+
+	DISALLOW_COPY_AND_ASSIGN(State);
+};
+
 // Calls glVertexAttribPointer.
 void vertex_attrib_pointer(int vertex_index, int num_items, int stride, int offset);
 
 
=== modified file 'src/graphic/graphic.cc'
--- src/graphic/graphic.cc	2015-01-28 07:32:57 +0000
+++ src/graphic/graphic.cc	2016-01-16 20:47:43 +0000
@@ -21,17 +21,23 @@
 
 #include <memory>
 
+#include "base/i18n.h"
 #include "base/log.h"
 #include "base/wexception.h"
 #include "build_info.h"
+#include "graphic/align.h"
 #include "graphic/animation.h"
+#include "graphic/build_texture_atlas.h"
+#include "graphic/font.h"
 #include "graphic/font_handler.h"
+#include "graphic/font_handler1.h"
 #include "graphic/gl/system_headers.h"
 #include "graphic/image.h"
 #include "graphic/image_io.h"
 #include "graphic/render_queue.h"
 #include "graphic/rendertarget.h"
 #include "graphic/screen.h"
+#include "graphic/text_layout.h"
 #include "graphic/texture.h"
 #include "io/filesystem/layered_filesystem.h"
 #include "io/streamwrite.h"
@@ -57,16 +63,17 @@
 
 }  // namespace
 
+Graphic::Graphic() : image_cache_(new ImageCache()), animation_manager_(new AnimationManager()) {
+}
+
 /**
  * Initialize the SDL video mode.
-*/
-Graphic::Graphic(int window_mode_w, int window_mode_h, bool init_fullscreen)
-   : m_window_mode_width(window_mode_w),
-     m_window_mode_height(window_mode_h),
-     m_update(true),
-     image_cache_(new ImageCache()),
-     animation_manager_(new AnimationManager())
-{
+ */
+void Graphic::initialize(int window_mode_w, int window_mode_h, bool init_fullscreen) {
+	m_window_mode_width = window_mode_w;
+	m_window_mode_height = window_mode_h;
+	m_requires_update = true;
+
 	// Request an OpenGL 2 context with double buffering.
 	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
@@ -74,12 +81,10 @@
 	SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
 
 	log("Graphics: Try to set Videomode %ux%u\n", m_window_mode_width, m_window_mode_height);
-	m_sdl_window = SDL_CreateWindow("Widelands Window",
-	                                SDL_WINDOWPOS_UNDEFINED,
-	                                SDL_WINDOWPOS_UNDEFINED,
-	                                m_window_mode_width,
-	                                m_window_mode_height,
-	                                SDL_WINDOW_OPENGL);
+	m_sdl_window =
+	   SDL_CreateWindow("Widelands Window", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+	                    m_window_mode_width, m_window_mode_height, SDL_WINDOW_OPENGL);
+
 	resolution_changed();
 	set_fullscreen(init_fullscreen);
 
@@ -96,22 +101,22 @@
 	glewExperimental = GL_TRUE;
 	GLenum err = glewInit();
 	if (err != GLEW_OK) {
-		log("glewInit returns %i\nYour OpenGL installation must be __very__ broken. %s\n",
-			 err, glewGetErrorString(err));
+		log("glewInit returns %i\nYour OpenGL installation must be __very__ broken. %s\n", err,
+		    glewGetErrorString(err));
 		throw wexception("glewInit returns %i: Broken OpenGL installation.", err);
 	}
 #endif
 
-	log("Graphics: OpenGL: Version \"%s\"\n",
-		 reinterpret_cast<const char*>(glGetString(GL_VERSION)));
+	log(
+	   "Graphics: OpenGL: Version \"%s\"\n", reinterpret_cast<const char*>(glGetString(GL_VERSION)));
 
 	GLboolean glBool;
 	glGetBooleanv(GL_DOUBLEBUFFER, &glBool);
 	log("Graphics: OpenGL: Double buffering %s\n", (glBool == GL_TRUE) ? "enabled" : "disabled");
 
-	GLint glInt;
-	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &glInt);
-	log("Graphics: OpenGL: Max texture size: %u\n", glInt);
+	GLint max_texture_size;
+	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
+	log("Graphics: OpenGL: Max texture size: %u\n", max_texture_size);
 
 	glDrawBuffer(GL_BACK);
 
@@ -134,12 +139,15 @@
 		    " pixel fmt %u\n"
 		    " size %d %d\n"
 		    "**** END GRAPHICS REPORT ****\n",
-		    SDL_GetCurrentVideoDriver(),
-		    disp_mode.format,
-		    disp_mode.w,
-		    disp_mode.h);
+		    SDL_GetCurrentVideoDriver(), disp_mode.format, disp_mode.w, disp_mode.h);
 		assert(SDL_BYTESPERPIXEL(disp_mode.format) == 4);
 	}
+
+
+	std::map<std::string, std::unique_ptr<Texture>> textures_in_atlas;
+	auto texture_atlases = build_texture_atlas(max_texture_size, &textures_in_atlas);
+	image_cache_->fill_with_texture_atlases(
+	   std::move(texture_atlases), std::move(textures_in_atlas));
 }
 
 Graphic::~Graphic()
@@ -239,14 +247,14 @@
 
 
 void Graphic::update() {
-	m_update = true;
+	m_requires_update = true;
 }
 
 /**
  * Returns true if parts of the screen have been marked for refreshing.
 */
 bool Graphic::need_update() const {
-	return m_update;
+	return m_requires_update;
 }
 
 /**
@@ -270,7 +278,7 @@
 	}
 
 	SDL_GL_SwapWindow(m_sdl_window);
-	m_update = false;
+	m_requires_update = false;
 }
 
 
 
=== modified file 'src/graphic/graphic.h'
--- src/graphic/graphic.h	2015-06-10 06:46:40 +0000
+++ src/graphic/graphic.h	2016-01-16 20:47:43 +0000
@@ -50,11 +50,14 @@
  */
 class Graphic {
 public:
-	// Creates a new graphic mode with the given resolution if fullscreen is
-	// false, otherwise a window that fills the screen.
-	Graphic(int window_mode_w, int window_mode_height, bool fullscreen);
+	// Creates a new Graphic object. Must call initialize before first use.
+	Graphic();
 	~Graphic();
 
+	// Initializes with the given resolution if fullscreen is false, otherwise a
+	// window that fills the screen.
+	void initialize(int window_mode_w, int window_mode_height, bool fullscreen);
+
 	// Gets and sets the resolution.
 	void change_resolution(int w, int h);
 	int get_xres();
@@ -96,7 +99,7 @@
 	/// A RenderTarget for screen_. This is initialized during init()
 	std::unique_ptr<RenderTarget> m_rendertarget;
 	/// This marks the complete screen for updating.
-	bool m_update;
+	bool m_requires_update;
 
 	/// Non-volatile cache of independent images.
 	std::unique_ptr<ImageCache> image_cache_;
 
=== modified file 'src/graphic/image_cache.cc'
--- src/graphic/image_cache.cc	2016-01-12 21:26:15 +0000
+++ src/graphic/image_cache.cc	2016-01-16 20:47:43 +0000
@@ -25,36 +25,11 @@
 #include <string>
 
 #include <SDL.h>
-#include <boost/format.hpp>
 
 #include "graphic/image.h"
 #include "graphic/image_io.h"
 #include "graphic/texture.h"
 
-ImageCache::ProxyImage::ProxyImage(std::unique_ptr<const Image> original_image)
-   : image_(std::move(original_image)) {
-}
-
-const Image& ImageCache::ProxyImage::image() {
-	return *image_;
-}
-
-void ImageCache::ProxyImage::set_image(std::unique_ptr<const Image> original_image) {
-	image_ = std::move(original_image);
-}
-
-int ImageCache::ProxyImage::width() const {
-	return image_->width();
-}
-
-int ImageCache::ProxyImage::height() const {
-	return image_->height();
-}
-
-const BlitData& ImageCache::ProxyImage::blit_data() const {
-	return image_->blit_data();
-}
-
 ImageCache::ImageCache() {
 }
 
@@ -68,16 +43,23 @@
 const Image* ImageCache::insert(const std::string& hash, std::unique_ptr<const Image> image) {
 	assert(!has(hash));
 	const Image* return_value = image.get();
-	images_.insert(make_pair(hash, std::unique_ptr<ProxyImage>(new ProxyImage(std::move(image)))));
+	images_.insert(std::make_pair(hash, std::move(image)));
 	return return_value;
 }
 
+void ImageCache::fill_with_texture_atlases(
+   std::vector<std::unique_ptr<Texture>> texture_atlases,
+   std::map<std::string, std::unique_ptr<Texture>> textures_in_atlas) {
+	texture_atlases_ = std::move(texture_atlases);
+	for (auto& pair : textures_in_atlas) {
+		images_.insert(std::move(pair));
+	}
+}
+
 const Image* ImageCache::get(const std::string& hash) {
-	ImageMap::const_iterator it = images_.find(hash);
+	auto it = images_.find(hash);
 	if (it == images_.end()) {
-		images_.insert(
-		   make_pair(hash, std::unique_ptr<ProxyImage>(new ProxyImage(load_image(hash)))));
-		return get(hash);
+		return images_.insert(std::make_pair(hash, std::move(load_image(hash)))).first->second.get();
 	}
 	return it->second.get();
 }
 
=== modified file 'src/graphic/image_cache.h'
--- src/graphic/image_cache.h	2016-01-07 16:21:36 +0000
+++ src/graphic/image_cache.h	2016-01-16 20:47:43 +0000
@@ -33,51 +33,36 @@
 
 // For historic reasons, most part of the Widelands code base expect that an
 // Image stays valid for the whole duration of the program run. This class is
-// the one that keeps ownership of all Images to ensure that this is true. Also
-// for historic reasons, this class will try to load in Image from disk when
-// its hash is not found. Other parts of Widelands will create images when they
-// do not exist in the cache yet and then put it into the cache and therefore
-// releasing their ownership.
+// the one that keeps ownership of all Images to ensure that this is true.
+// Other parts of Widelands will create images when they do not exist in the
+// cache yet and then put it into the cache and therefore releasing their
+// ownership.
 class ImageCache {
 public:
 	ImageCache();
 	~ImageCache();
 
-	// Insert the given Image into the cache.
-	// Will return a pointer to the freshly inserted image for convenience.
+	// Insert the 'image' into the cache and returns a pointer to the inserted
+	// image for convenience.
 	const Image* insert(const std::string& hash, std::unique_ptr<const Image> image);
 
-	// Returns the image associated with the given hash. If no image by this
-	// hash is known, it will try to load one from disk with the filename =
-	// hash. If this fails, it will throw an error.
+	// Returns the image associated with the 'hash'. If no image by this hash is
+	// known, it will try to load one from disk with the filename = hash. If
+	// this fails, it will throw an error.
 	const Image* get(const std::string& hash);
 
-	// Returns true if the given hash is stored in the cache.
+	// Returns true if the 'hash' is stored in the cache.
 	bool has(const std::string& hash) const;
 
+	// Fills the image cache with the hash -> Texture map 'textures_in_atlas'
+	// and take ownership of 'texture_atlases' so that the textures stay valid.
+	void
+	fill_with_texture_atlases(std::vector<std::unique_ptr<Texture>> texture_atlases,
+	                          std::map<std::string, std::unique_ptr<Texture>> textures_in_atlas);
+
 private:
-	// We return a wrapped Image so that we can swap out the pointer to the
-	// image under our user. This can happen when we move an Image from a stand
-	// alone texture into being a subrect of a texture atlas.
-	class ProxyImage : public Image {
-	public:
-		ProxyImage(std::unique_ptr<const Image> image);
-
-		const Image& image();
-		void set_image(std::unique_ptr<const Image> image);
-
-		int width() const override;
-		int height() const override;
-		const BlitData& blit_data() const override;
-
-	private:
-		std::unique_ptr<const Image> image_;
-	};
-
-	using ImageMap = std::map<std::string, std::unique_ptr<ProxyImage>>;
-
 	std::vector<std::unique_ptr<Texture>> texture_atlases_;
-	ImageMap images_;  /// hash of cached filename/image pairs
+	std::map<std::string, std::unique_ptr<const Image>> images_;
 
 	DISALLOW_COPY_AND_ASSIGN(ImageCache);
 };
 
=== modified file 'src/graphic/render_queue.cc'
--- src/graphic/render_queue.cc	2016-01-10 11:56:27 +0000
+++ src/graphic/render_queue.cc	2016-01-16 20:47:43 +0000
@@ -22,7 +22,6 @@
 #include <algorithm>
 #include <limits>
 
-#include "base/log.h"
 #include "base/rect.h"
 #include "base/wexception.h"
 #include "graphic/gl/blit_program.h"
@@ -76,25 +75,15 @@
 	return (z_value << 40) | (program_id << 36) | extra_value;
 }
 
-// Construct 'args' used by the individual programs out of 'item'.
-inline void from_item(const RenderQueue::Item& item, VanillaBlitProgram::Arguments* args) {
-	args->texture = item.vanilla_blit_arguments.texture;
-	args->opacity = item.vanilla_blit_arguments.opacity;
-}
-
-inline void from_item(const RenderQueue::Item& item, MonochromeBlitProgram::Arguments* args) {
-	args->texture = item.monochrome_blit_arguments.texture;
-	args->blend = item.monochrome_blit_arguments.blend;
-}
-
 inline void from_item(const RenderQueue::Item& item, FillRectProgram::Arguments* args) {
 	args->color = item.rect_arguments.color;
 }
 
-inline void from_item(const RenderQueue::Item& item, BlendedBlitProgram::Arguments* args) {
-	args->texture = item.blended_blit_arguments.texture;
-	args->blend = item.blended_blit_arguments.blend;
-	args->mask = item.blended_blit_arguments.mask;
+inline void from_item(const RenderQueue::Item& item, BlitProgram::Arguments* args) {
+	args->texture = item.blit_arguments.texture;
+	args->blend = item.blit_arguments.blend;
+	args->mask = item.blit_arguments.mask;
+	args->blit_mode = item.blit_arguments.mode;
 }
 
 inline void from_item(const RenderQueue::Item& item, DrawLineProgram::Arguments* args) {
@@ -167,15 +156,7 @@
 
 	switch (given_item.program_id) {
 		case Program::kBlit:
-		   extra_value = given_item.vanilla_blit_arguments.texture.texture_id;
-		 break;
-
-		case Program::kBlitMonochrome:
-		   extra_value = given_item.monochrome_blit_arguments.texture.texture_id;
-			break;
-
-		case Program::kBlitBlended:
-		   extra_value = given_item.blended_blit_arguments.texture.texture_id;
+		   extra_value = given_item.blit_arguments.texture.texture_id;
 			break;
 
 		case Program::kLine:
@@ -212,7 +193,7 @@
 		throw wexception("Too many drawn layers. Ran out of z-values.");
 	}
 
-	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	Gl::State::instance().bind_framebuffer(0, 0);
 	glViewport(0, 0, screen_width, screen_height);
 
 	glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
@@ -231,7 +212,6 @@
 	blended_items_.clear();
 
 	glDepthMask(GL_TRUE);
-
 	next_z_ = 1;
 }
 
@@ -241,18 +221,8 @@
 		const Item& item = items[i];
 		switch (item.program_id) {
 		case Program::kBlit:
-			VanillaBlitProgram::instance().draw(
-			   batch_up<VanillaBlitProgram::Arguments>(Program::kBlit, items, &i));
-		 break;
-
-		case Program::kBlitMonochrome:
-			MonochromeBlitProgram::instance().draw(
-			   batch_up<MonochromeBlitProgram::Arguments>(Program::kBlitMonochrome, items, &i));
-			break;
-
-		case Program::kBlitBlended:
-			BlendedBlitProgram::instance().draw(
-			   batch_up<BlendedBlitProgram::Arguments>(Program::kBlitBlended, items, &i));
+			BlitProgram::instance().draw(
+			   batch_up<BlitProgram::Arguments>(Program::kBlit, items, &i));
 			break;
 
 		case Program::kLine:
 
=== modified file 'src/graphic/render_queue.h'
--- src/graphic/render_queue.h	2016-01-08 21:00:39 +0000
+++ src/graphic/render_queue.h	2016-01-16 20:47:43 +0000
@@ -28,6 +28,7 @@
 #include "base/macros.h"
 #include "base/rect.h"
 #include "graphic/blend_mode.h"
+#include "graphic/blit_mode.h"
 #include "graphic/color.h"
 #include "graphic/gl/fields_to_draw.h"
 #include "logic/description_maintainer.h"
@@ -82,24 +83,18 @@
 		kTerrainDither,
 		kTerrainRoad,
 		kBlit,
-		kBlitMonochrome,
-		kBlitBlended,
 		kRect,
 		kLine,
 		kHighestProgramId,
 	};
 
-	struct VanillaBlitArguments {
-		BlitData texture;
-		float opacity;
-	};
-
 	struct MonochromeBlitArguments {
 		BlitData texture;
 		RGBAColor blend;
 	};
 
-	struct BlendedBlitArguments {
+	struct BlitArguments {
+		BlitMode mode;
 		BlitData texture;
 		BlitData mask;
 		RGBAColor blend;
@@ -154,9 +149,7 @@
 		BlendMode blend_mode;
 
 		union {
-			VanillaBlitArguments vanilla_blit_arguments;
-			MonochromeBlitArguments monochrome_blit_arguments;
-			BlendedBlitArguments blended_blit_arguments;
+			BlitArguments blit_arguments;
 			TerrainArguments terrain_arguments;
 			RectArguments rect_arguments;
 			LineArguments line_arguments;
 
=== modified file 'src/graphic/screen.cc'
--- src/graphic/screen.cc	2016-01-05 11:28:54 +0000
+++ src/graphic/screen.cc	2016-01-16 20:47:43 +0000
@@ -65,11 +65,13 @@
                      float opacity,
                      BlendMode blend_mode) {
 	RenderQueue::Item i;
+	i.destination_rect = dst_rect;
 	i.program_id = RenderQueue::Program::kBlit;
 	i.blend_mode = blend_mode;
-	i.destination_rect = dst_rect;
-	i.vanilla_blit_arguments.texture = texture;
-	i.vanilla_blit_arguments.opacity = opacity;
+	i.blit_arguments.texture = texture;
+	i.blit_arguments.mask.texture_id = 0;
+	i.blit_arguments.blend = RGBAColor(0, 0, 0, 255 * opacity);
+	i.blit_arguments.mode = BlitMode::kDirect;
 	RenderQueue::instance().enqueue(i);
 }
 
@@ -79,11 +81,12 @@
                              const RGBColor& blend) {
 	RenderQueue::Item i;
 	i.destination_rect = dst_rect;
-	i.program_id = RenderQueue::Program::kBlitBlended;
+	i.program_id = RenderQueue::Program::kBlit;
 	i.blend_mode = BlendMode::UseAlpha;
-	i.blended_blit_arguments.texture = texture;
-	i.blended_blit_arguments.mask = mask;
-	i.blended_blit_arguments.blend = blend;
+	i.blit_arguments.texture = texture;
+	i.blit_arguments.mask = mask;
+	i.blit_arguments.blend = blend;
+	i.blit_arguments.mode = BlitMode::kBlendedWithMask;
 	RenderQueue::instance().enqueue(i);
 }
 
@@ -91,11 +94,13 @@
                                 const BlitData& texture,
                                 const RGBAColor& blend) {
 	RenderQueue::Item i;
-	i.program_id = RenderQueue::Program::kBlitMonochrome;
+	i.destination_rect = dst_rect;
+	i.program_id = RenderQueue::Program::kBlit;
 	i.blend_mode = BlendMode::UseAlpha;
-	i.destination_rect = dst_rect;
-	i.monochrome_blit_arguments.texture = texture;
-	i.monochrome_blit_arguments.blend = blend;
+	i.blit_arguments.texture = texture;
+	i.blit_arguments.mask.texture_id = 0;
+	i.blit_arguments.blend = blend;
+	i.blit_arguments.mode = BlitMode::kMonochrome;
 	RenderQueue::instance().enqueue(i);
 }
 
 
=== modified file 'src/graphic/surface.h'
--- src/graphic/surface.h	2016-01-04 20:54:08 +0000
+++ src/graphic/surface.h	2016-01-16 20:47:43 +0000
@@ -48,14 +48,14 @@
 	          const float opacity,
 	          BlendMode blend_mode);
 
-	/// This draws a playercolor blended image. See BlendedBlitProgram.
+	/// This draws a playercolor blended image.
 	void blit_blended(const Rect& dst,
 	                  const Image& image,
 	                  const Image& texture_mask,
 	                  const Rect& srcrc,
 	                  const RGBColor& blend);
 
-	/// This draws a grayed out version. See MonochromeBlitProgram.
+	/// This draws a grayed out version.
 	void
 	blit_monochrome(const Rect& dst, const Image&, const Rect& srcrc, const RGBAColor& multiplier);
 
 
=== modified file 'src/graphic/text/test/render_richtext.cc'
--- src/graphic/text/test/render_richtext.cc	2015-03-01 09:21:20 +0000
+++ src/graphic/text/test/render_richtext.cc	2016-01-16 20:47:43 +0000
@@ -98,7 +98,8 @@
 	g_fs = new LayeredFileSystem();
 	g_fs->add_file_system(&FileSystem::create(INSTALL_DATADIR));
 
-	g_gr = new Graphic(1, 1, false);
+	g_gr = new Graphic();
+	g_gr->initialize(1, 1, false);
 }
 
 }  // namespace
 
=== modified file 'src/graphic/texture.cc'
--- src/graphic/texture.cc	2016-01-12 08:17:04 +0000
+++ src/graphic/texture.cc	2016-01-16 20:47:43 +0000
@@ -167,6 +167,7 @@
 Texture::~Texture()
 {
 	if (m_owns_texture) {
+		Gl::State::instance().unbind_texture_if_bound(m_blit_data.texture_id);
 		glDeleteTextures(1, &m_blit_data.texture_id);
 	}
 }
@@ -192,7 +193,7 @@
 
 	m_owns_texture = true;
 	glGenTextures(1, &m_blit_data.texture_id);
-	glBindTexture(GL_TEXTURE_2D, m_blit_data.texture_id);
+	Gl::State::instance().bind(GL_TEXTURE0, m_blit_data.texture_id);
 
 	// set texture filter to use linear filtering. This looks nicer for resized
 	// texture. Most textures and images are not resized so the filtering
@@ -215,9 +216,8 @@
 
 	m_pixels.reset(new uint8_t[width() * height() * 4]);
 
-	glBindTexture(GL_TEXTURE_2D, m_blit_data.texture_id);
+	Gl::State::instance().bind(GL_TEXTURE0, m_blit_data.texture_id);
 	glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_pixels.get());
-	glBindTexture(GL_TEXTURE_2D, 0);
 }
 
 void Texture::unlock(UnlockMode mode) {
@@ -227,11 +227,9 @@
 	assert(m_pixels);
 
 	if (mode == Unlock_Update) {
-		glBindTexture(GL_TEXTURE_2D, m_blit_data.texture_id);
-		glTexImage2D
-            (GL_TEXTURE_2D, 0, static_cast<GLint>(GL_RGBA), width(), height(), 0, GL_RGBA,
-			 GL_UNSIGNED_BYTE,  m_pixels.get());
-		glBindTexture(GL_TEXTURE_2D, 0);
+		Gl::State::instance().bind(GL_TEXTURE0, m_blit_data.texture_id);
+		glTexImage2D(GL_TEXTURE_2D, 0, static_cast<GLint>(GL_RGBA), width(), height(), 0, GL_RGBA,
+		             GL_UNSIGNED_BYTE, m_pixels.get());
 	}
 
 	m_pixels.reset(nullptr);
@@ -265,8 +263,8 @@
 
 
 void Texture::setup_gl() {
-	glBindFramebuffer(GL_FRAMEBUFFER, GlFramebuffer::instance().id());
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_blit_data.texture_id, 0);
+	Gl::State::instance().bind_framebuffer(
+	   GlFramebuffer::instance().id(), m_blit_data.texture_id);
 	glViewport(0, 0, width(), height());
 }
 
@@ -275,7 +273,8 @@
                      float opacity,
                      BlendMode blend_mode) {
 	setup_gl();
-	VanillaBlitProgram::instance().draw(dst_rect, 0.f, texture, opacity, blend_mode);
+	BlitProgram::instance().draw(dst_rect, 0.f, texture, BlitData{0, 0, 0, Rect()},
+	                             RGBAColor(0, 0, 0, 255 * opacity), blend_mode);
 }
 
 void Texture::do_blit_blended(const FloatRect& dst_rect,
@@ -284,14 +283,14 @@
                               const RGBColor& blend) {
 
 	setup_gl();
-	BlendedBlitProgram::instance().draw(dst_rect, 0.f, texture, mask, blend);
+	BlitProgram::instance().draw(dst_rect, 0.f, texture, mask, blend, BlendMode::UseAlpha);
 }
 
 void Texture::do_blit_monochrome(const FloatRect& dst_rect,
                                  const BlitData& texture,
                                  const RGBAColor& blend) {
 	setup_gl();
-	MonochromeBlitProgram::instance().draw(dst_rect, 0.f, texture, blend);
+	BlitProgram::instance().draw_monochrome(dst_rect, 0.f, texture, blend);
 }
 
 void
 
=== modified file 'src/logic/CMakeLists.txt'
--- src/logic/CMakeLists.txt	2016-01-10 11:36:05 +0000
+++ src/logic/CMakeLists.txt	2016-01-16 20:47:43 +0000
@@ -237,7 +237,6 @@
     graphic_surface
     graphic_text
     graphic_text_layout
-    graphic_texture_atlas
     helper
     io_fileread
     io_filesystem
 
=== modified file 'src/logic/map_info.cc'
--- src/logic/map_info.cc	2015-03-01 09:21:20 +0000
+++ src/logic/map_info.cc	2016-01-16 20:47:43 +0000
@@ -48,7 +48,8 @@
 	g_fs = new LayeredFileSystem();
 	g_fs->add_file_system(&FileSystem::create(INSTALL_DATADIR));
 
-	g_gr = new Graphic(1, 1, false);
+	g_gr = new Graphic();
+	g_gr->initialize(1, 1, false);
 }
 
 }  // namespace
 
=== modified file 'src/logic/map_objects/tribes/road_textures.cc'
--- src/logic/map_objects/tribes/road_textures.cc	2015-11-28 22:29:26 +0000
+++ src/logic/map_objects/tribes/road_textures.cc	2016-01-16 20:47:43 +0000
@@ -21,18 +21,18 @@
 
 #include <memory>
 
-const Texture& RoadTextures::get_normal_texture(int x, int y, int direction) const {
+const Image& RoadTextures::get_normal_texture(int x, int y, int direction) const {
 	return *normal_textures_.at((x + y + direction) % normal_textures_.size());
 }
 
-const Texture& RoadTextures::get_busy_texture(int x, int y, int direction) const {
+const Image& RoadTextures::get_busy_texture(int x, int y, int direction) const {
 	return *busy_textures_.at((x + y + direction) % busy_textures_.size());
 }
 
-void RoadTextures::add_normal_road_texture(std::unique_ptr<Texture> texture) {
-	normal_textures_.emplace_back(std::move(texture));
+void RoadTextures::add_normal_road_texture(const Image* image) {
+	normal_textures_.emplace_back(image);
 }
 
-void RoadTextures::add_busy_road_texture(std::unique_ptr<Texture> texture) {
-	busy_textures_.emplace_back(std::move(texture));
+void RoadTextures::add_busy_road_texture(const Image* image) {
+	busy_textures_.emplace_back(image);
 }
 
=== modified file 'src/logic/map_objects/tribes/road_textures.h'
--- src/logic/map_objects/tribes/road_textures.h	2015-11-28 22:29:26 +0000
+++ src/logic/map_objects/tribes/road_textures.h	2016-01-16 20:47:43 +0000
@@ -23,23 +23,23 @@
 #include <memory>
 #include <vector>
 
-#include "graphic/texture.h"
+#include "graphic/image.h"
 
 // Simple container to give access of the road textures of a tribe.
 class RoadTextures {
 public:
 	// Returns the road texture that should be used for the Cooordinate x, y and
 	// the road going into direction 'direction' (which can be any number).
-	const Texture& get_normal_texture(int x, int y, int direction) const;
-	const Texture& get_busy_texture(int x, int y, int direction) const;
+	const Image& get_normal_texture(int x, int y, int direction) const;
+	const Image& get_busy_texture(int x, int y, int direction) const;
 
 	// Adds a new road texture.
-	void add_normal_road_texture(std::unique_ptr<Texture> texture);
-	void add_busy_road_texture(std::unique_ptr<Texture> texture);
+	void add_normal_road_texture(const Image* texture);
+	void add_busy_road_texture(const Image* texture);
 
 private:
-	std::vector<std::unique_ptr<Texture>> normal_textures_;
-	std::vector<std::unique_ptr<Texture>> busy_textures_;
+	std::vector<const Image*> normal_textures_;
+	std::vector<const Image*> busy_textures_;
 };
 
 #endif  // end of include guard: WL_LOGIC_MAP_OBJECTS_TRIBES_ROAD_TEXTURES_H
 
=== modified file 'src/logic/map_objects/tribes/tribe_descr.cc'
--- src/logic/map_objects/tribes/tribe_descr.cc	2016-01-08 21:00:39 +0000
+++ src/logic/map_objects/tribes/tribe_descr.cc	2016-01-16 20:47:43 +0000
@@ -319,12 +319,12 @@
 	return busy_road_paths_;
 }
 
-void TribeDescr::add_normal_road_texture(std::unique_ptr<Texture> texture) {
-	road_textures_.add_normal_road_texture(std::move(texture));
+void TribeDescr::add_normal_road_texture(const Image* texture) {
+	road_textures_.add_normal_road_texture(texture);
 }
 
-void TribeDescr::add_busy_road_texture(std::unique_ptr<Texture> texture) {
-	road_textures_.add_busy_road_texture(std::move(texture));
+void TribeDescr::add_busy_road_texture(const Image* texture) {
+	road_textures_.add_busy_road_texture(texture);
 }
 
 const RoadTextures& TribeDescr::road_textures() const {
 
=== modified file 'src/logic/map_objects/tribes/tribe_descr.h'
--- src/logic/map_objects/tribes/tribe_descr.h	2015-11-28 22:29:26 +0000
+++ src/logic/map_objects/tribes/tribe_descr.h	2016-01-16 20:47:43 +0000
@@ -114,10 +114,9 @@
 	const std::vector<std::string>& normal_road_paths() const;
 	const std::vector<std::string>& busy_road_paths() const;
 
-	// Add the corresponding texture (which probably resides in a
-	// texture atlas) for roads.
-	void add_normal_road_texture(std::unique_ptr<Texture> texture);
-	void add_busy_road_texture(std::unique_ptr<Texture> texture);
+	// Add the corresponding texture for roads.
+	void add_normal_road_texture(const Image* texture);
+	void add_busy_road_texture(const Image* texture);
 
 	// The road textures used for drawing roads.
 	const RoadTextures& road_textures() const;
 
=== modified file 'src/logic/map_objects/tribes/tribes.cc'
--- src/logic/map_objects/tribes/tribes.cc	2016-01-12 21:26:15 +0000
+++ src/logic/map_objects/tribes/tribes.cc	2016-01-16 20:47:43 +0000
@@ -22,9 +22,6 @@
 #include <memory>
 
 #include "graphic/graphic.h"
-#include "graphic/image_io.h"
-#include "graphic/texture_atlas.h"
-#include "io/filesystem/layered_filesystem.h"
 #include "logic/game_data_error.h"
 
 namespace Widelands {
@@ -343,38 +340,15 @@
 
 void Tribes::load_graphics()
 {
-	// Construct and hold on to the texture atlas that contains all road images.
-	TextureAtlas ta;
-
 	// These will be deleted at the end of the method.
 	std::vector<std::unique_ptr<Texture>> individual_textures_;
 	for (size_t tribeindex = 0; tribeindex < nrtribes(); ++tribeindex) {
 		TribeDescr* tribe = tribes_->get_mutable(tribeindex);
 		for (const std::string& texture_path : tribe->normal_road_paths()) {
-			individual_textures_.emplace_back(load_image(texture_path, g_fs));
-			ta.add(*individual_textures_.back());
+			tribe->add_normal_road_texture(g_gr->images().get(texture_path));
 		}
 		for (const std::string& texture_path : tribe->busy_road_paths()) {
-			individual_textures_.emplace_back(load_image(texture_path, g_fs));
-			ta.add(*individual_textures_.back());
-		}
-	}
-
-	std::vector<TextureAtlas::PackedTexture> packed_texture;
-	std::vector<std::unique_ptr<Texture>> texture_atlases;
-	ta.pack(1024, &texture_atlases, &packed_texture);
-
-	assert(texture_atlases.size() == 1);
-	road_texture_ = std::move(texture_atlases[0]);
-
-	size_t next_texture_to_move = 0;
-	for (size_t tribeindex = 0; tribeindex < nrtribes(); ++tribeindex) {
-		TribeDescr* tribe = tribes_->get_mutable(tribeindex);
-		for (size_t i = 0; i < tribe->normal_road_paths().size(); ++i) {
-			tribe->add_normal_road_texture(std::move(packed_texture.at(next_texture_to_move++).texture));
-		}
-		for (size_t i = 0; i < tribe->busy_road_paths().size(); ++i) {
-			tribe->add_busy_road_texture(std::move(packed_texture.at(next_texture_to_move++).texture));
+			tribe->add_busy_road_texture(g_gr->images().get(texture_path));
 		}
 	}
 }
 
=== modified file 'src/logic/map_objects/tribes/tribes.h'
--- src/logic/map_objects/tribes/tribes.h	2015-11-28 22:29:26 +0000
+++ src/logic/map_objects/tribes/tribes.h	2016-01-16 20:47:43 +0000
@@ -154,8 +154,6 @@
 	std::unique_ptr<DescriptionMaintainer<WorkerDescr>> workers_;
 	std::unique_ptr<DescriptionMaintainer<TribeDescr>> tribes_;
 
-	std::unique_ptr<Texture> road_texture_; // Used in loading the road texture graphics
-
 	DISALLOW_COPY_AND_ASSIGN(Tribes);
 };
 
 
=== modified file 'src/logic/map_objects/world/terrain_description.cc'
--- src/logic/map_objects/world/terrain_description.cc	2015-12-11 19:06:50 +0000
+++ src/logic/map_objects/world/terrain_description.cc	2016-01-16 20:47:43 +0000
@@ -160,15 +160,15 @@
 TerrainDescription::~TerrainDescription() {
 }
 
-const Texture& TerrainDescription::get_texture(uint32_t gametime) const {
+const Image& TerrainDescription::get_texture(uint32_t gametime) const {
 	return *textures_.at((gametime / frame_length_) % textures_.size());
 }
 
-void TerrainDescription::add_texture(std::unique_ptr<Texture> texture) {
+void TerrainDescription::add_texture(const Image* texture) {
 	if (texture->width() != kTextureSideLength || texture->height() != kTextureSideLength) {
 		throw wexception("Tried to add a texture with wrong size.");
 	}
-	textures_.emplace_back(std::move(texture));
+	textures_.emplace_back(texture);
 }
 
 const std::vector<std::string>& TerrainDescription::texture_paths() const {
 
=== modified file 'src/logic/map_objects/world/terrain_description.h'
--- src/logic/map_objects/world/terrain_description.h	2015-12-11 19:06:50 +0000
+++ src/logic/map_objects/world/terrain_description.h	2016-01-16 20:47:43 +0000
@@ -73,8 +73,8 @@
 	const std::vector<std::string>& texture_paths() const;
 
 	/// Returns the texture for the given gametime.
-	const Texture& get_texture(uint32_t gametime) const;
-	void add_texture(std::unique_ptr<Texture> texture);
+	const Image& get_texture(uint32_t gametime) const;
+	void add_texture(const Image* texture);
 
 	// Sets the base minimap color.
 	void set_minimap_color(const RGBColor& color);
@@ -140,7 +140,7 @@
 	double fertility_;
 	double humidity_;
 	std::vector<std::string> texture_paths_;
-	std::vector<std::unique_ptr<Texture>> textures_;
+	std::vector<const Image*> textures_;
 	RGBColor    minimap_colors_[256];
 
 	DISALLOW_COPY_AND_ASSIGN(TerrainDescription);
 
=== modified file 'src/logic/map_objects/world/world.cc'
--- src/logic/map_objects/world/world.cc	2016-01-12 21:26:15 +0000
+++ src/logic/map_objects/world/world.cc	2016-01-16 20:47:43 +0000
@@ -23,8 +23,6 @@
 
 #include "base/i18n.h"
 #include "graphic/image_io.h"
-#include "graphic/texture.h"
-#include "graphic/texture_atlas.h"
 #include "logic/game_data_error.h"
 #include "logic/map_objects/bob.h"
 #include "logic/map_objects/immovable.h"
@@ -49,11 +47,6 @@
 }
 
 void World::load_graphics() {
-	TextureAtlas ta;
-
-	// These will be deleted at the end of the method.
-	std::vector<std::unique_ptr<Texture>> individual_textures_;
-
 	for (size_t i = 0; i < terrains_->size(); ++i) {
 		TerrainDescription* terrain = terrains_->get_mutable(i);
 		for (size_t j = 0; j < terrain->texture_paths().size(); ++j) {
@@ -67,23 +60,7 @@
 				terrain->set_minimap_color(
 				   RGBColor(top_left_pixel_color.r, top_left_pixel_color.g, top_left_pixel_color.b));
 			}
-			individual_textures_.emplace_back(new Texture(sdl_surface));
-			ta.add(*individual_textures_.back());
-		}
-	}
-
-	std::vector<TextureAtlas::PackedTexture> packed_texture;
-	std::vector<std::unique_ptr<Texture>> texture_atlases;
-	ta.pack(1024, &texture_atlases, &packed_texture);
-
-	assert(texture_atlases.size() == 1);
-	terrain_texture_ = std::move(texture_atlases[0]);
-
-	int next_texture_to_move = 0;
-	for (size_t i = 0; i < terrains_->size(); ++i) {
-		TerrainDescription* terrain = terrains_->get_mutable(i);
-		for (size_t j = 0; j < terrain->texture_paths().size(); ++j) {
-			terrain->add_texture(std::move(packed_texture.at(next_texture_to_move++).texture));
+			terrain->add_texture(g_gr->images().get(terrain->texture_paths()[j]));
 		}
 	}
 }
 
=== modified file 'src/logic/map_objects/world/world.h'
--- src/logic/map_objects/world/world.h	2015-11-28 22:29:26 +0000
+++ src/logic/map_objects/world/world.h	2016-01-16 20:47:43 +0000
@@ -28,7 +28,6 @@
 
 class LuaInterface;
 class LuaTable;
-class Texture;
 
 namespace Widelands {
 
@@ -99,7 +98,6 @@
 	std::unique_ptr<DescriptionMaintainer<ResourceDescription>> resources_;
 	std::unique_ptr<DescriptionMaintainer<EditorCategory>> editor_terrain_categories_;
 	std::unique_ptr<DescriptionMaintainer<EditorCategory>> editor_immovable_categories_;
-	std::unique_ptr<Texture> terrain_texture_;
 
 	DISALLOW_COPY_AND_ASSIGN(World);
 };
 
=== modified file 'src/wlapplication.cc'
--- src/wlapplication.cc	2015-11-28 22:29:26 +0000
+++ src/wlapplication.cc	2016-01-16 20:47:43 +0000
@@ -271,19 +271,32 @@
 	changedir_on_mac();
 	cleanup_replays();
 
-	// handling of graphics
-	init_hardware();
-
-	// This might grab the input.
-	refresh_graphics();
+	Section & config = g_options.pull_section("global");
+
+	//Start the SDL core
+	if (SDL_Init(SDL_INIT_VIDEO) == -1)
+		throw wexception("Failed to initialize SDL, no valid video driver: %s", SDL_GetError());
+
+	SDL_ShowCursor(SDL_DISABLE);
+	g_gr = new Graphic();
 
 	if (TTF_Init() == -1)
 		throw wexception
 			("True Type library did not initialize: %s\n", TTF_GetError());
 
-	UI::g_fh1 = UI::create_fonthandler(g_gr); // This will create the fontset, so loading it first.
+	UI::g_fh1 =
+	   UI::create_fonthandler(&g_gr->images());  // This will create the fontset, so loading it first.
 	UI::g_fh = new UI::FontHandler();
 
+	g_gr->initialize(config.get_int("xres", DEFAULT_RESOLUTION_W),
+	                 config.get_int("yres", DEFAULT_RESOLUTION_H),
+	                 config.get_bool("fullscreen", false));
+	g_sound_handler.init(); //  TODO(unknown): memory leak!
+
+
+	// This might grab the input.
+	refresh_graphics();
+
 	if (SDLNet_Init() == -1)
 		throw wexception("SDLNet_Init failed: %s\n", SDLNet_GetError());
 
@@ -779,33 +792,6 @@
 	}
 }
 
-/**
- * Start the hardware: switch to graphics mode, start sound handler
- *
- * \pre The locale must be known before calling this
- *
- * \return true if there were no fatal errors that prevent the game from running
- */
-bool WLApplication::init_hardware() {
-	Section & s = g_options.pull_section("global");
-
-	//Start the SDL core
-	if (SDL_Init(SDL_INIT_VIDEO) == -1)
-		throw wexception
-			("Failed to initialize SDL, no valid video driver: %s",
-			 SDL_GetError());
-
-	SDL_ShowCursor(SDL_DISABLE);
-
-	g_gr = new Graphic(s.get_int("xres", DEFAULT_RESOLUTION_W),
-	                   s.get_int("yres", DEFAULT_RESOLUTION_H),
-	                   s.get_bool("fullscreen", false));
-
-	g_sound_handler.init(); //  TODO(unknown): memory leak!
-
-	return true;
-}
-
 void WLApplication::shutdown_hardware()
 {
 	delete g_gr;
 
=== modified file 'src/wlapplication.h'
--- src/wlapplication.h	2015-11-08 17:31:06 +0000
+++ src/wlapplication.h	2016-01-16 20:47:43 +0000
@@ -191,7 +191,6 @@
 	void init_language();
 	void shutdown_settings();
 
-	bool init_hardware();
 	void shutdown_hardware();
 
 	void parse_commandline(int argc, char const * const * argv);