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

[SirVer]

- Support maximum dimensions when baking texture atlases.
- Change wl_make_texture_atlas to build a full texture atlas for all images in the game.

This branch should not bring any functional change to the game at all. The focus here is to make the binary wl_make_texture_atlas create a usable texture atlas for the game, i.e. it bakes resource. A followup branch will make use of the texture atlas in game.

Testers:
Please do the following after building the branch. Go into the root directory of the bzr repository
and run the binary, for example this should work if you use compile.sh:

build/src/graphic/wl_make_texture_atlas <maximum texture size, for example 8192>

This should generate some output*.png and a output.lua.

I am mostly interested in two things:
1) how long does it take to run this command
2) What is your maximum texture size? The program prints it at the very beginning.

Potential Impact:
Right now, Widelands has 31919 images. They are loaded on-demand from disk which is bad, because it makes the game stutter if you have a slow HD. It also makes the code ugly, because not all images are treated the same. They are also loaded into a separate texture each which leads to very many OpenGL context switches for each frame during rendering.
A 3-5 year old graphics card should be able to deal with 8192x8192 textures, no prob. Given that resolution, all our images can fit into 2 OpenGL textures when packed. These two PNGs could be loaded very quickly on game startup and we will have no loading stutter and much less context switches. This will be the biggest performance gain in rendering ever.

Open questions:
For the followup branch there are two possible implementations:

1) build a texture atlas on startup and cache it into ~/.wideland/cache, so that it does not need to be rebuild for the particular Widelands version. On my system, building the atlases takes ~30seconds, I think it is acceptable for the first startup to take that long.
Pros/Cons:
+ Nearly no change in deployment and development for Widelands devs.
- Whenever you commit, your next Widelands startup will be slow because the version has changed and therefor the atlases will be rebuild.
- First Widelands start will be slow for new users. First impression are important though!
- Building the cache is a code path that will not be often executed, so bugs might slip in more easily.
- Graphic devs need to manually nuke the cache when they change a graphic, since the shipped images will not be used if the cache is there.

2) build texture atlases offline for various resolutions and only ship these in the release version.
- Graphic dev becomes harder, because graphic devs need to bake the texture atlases before starting the game every time they change a graphic to see them in the game.
- released versions can no longer tweak a graphic or add new ones, since only the texture atlases are ever used and they are hard to understand for a human.
+ The release becomes way smaller, since we would only ship a few images instead of thousands. This could even be pushed further, by 'baking' all of our resources into a simpler package that is easier to load on start - similar to how the current wl_make_texture_atlas 'compiles' a lua file that contains the coordinates for the texture atlas.

Which one do you like better, 1 or 2?

[TiborB (tiborb95)]

Can the building be part of installation process? On linux, when installing package, usually it is possible to run an "after" script...
On windows - I have no idea how the installation look, but 30 seconds would be bearable...

I dont understand that stuff fully, but an user can pick various resolutions + windowed/fullscreen mode on his/her PC - no problem with this?

[Tino (tino79)]

Info:
Graphics: Try to set Videomode 1x1
Graphics: OpenGL: Version "4.3.0 - Build 10.18.14.4139"
Graphics: OpenGL: Double buffering enabled
Graphics: OpenGL: Max texture size: 16384

Runtime to do a wl_make_texture_atlas 8192 => ~60 seconds , 16384=> ~74 seconds.
Hardware is Lenovo x240 Notebook with an Intel Core i7-4600U.

My vote goes to variant 2. On windows system with AV software there should be a performance gain because fewer files have to be scanned.
I don't think 60 seconds are a blocker for Graphic devs: How long does it take to e.g. render a new animation with Blender? Does this both then end up too long?

What about building a small testing app which just renders/animates single widelands animations for a first visual check?

[bunnybot (widelandsofficial)]

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

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

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.

[kaputtnik (franku)]

Is the atlas used in this branch?

Run time on my computer (AMD x2 5200+):

time ./build/src/graphic/wl_make_texture_atlas 8192
Graphics: Try to set Videomode 1x1
Graphics: OpenGL: Version "3.0 Mesa 11.1.0"
Graphics: OpenGL: Double buffering enabled
Graphics: OpenGL: Max texture size: 16384
**** GRAPHICS REPORT ****
 VIDEO DRIVER x11
 pixel fmt 370546692
 size 640 480
**** END GRAPHICS REPORT ****
[libpng warnings]

real 2m17.223s
user 1m27.270s
sys 0m40.343s

2 Minutes.

Resulting file size of output_00.png: 33M (34347800 byte)

[TiborB (tiborb95)]

$ time ./wl_make_texture_atlas 8192
Graphics: Try to set Videomode 1x1
Graphics: OpenGL: Version "3.0 Mesa 11.0.7"
Graphics: OpenGL: Double buffering enabled
Graphics: OpenGL: Max texture size: 8192
**** GRAPHICS REPORT ****
 VIDEO DRIVER x11
 pixel fmt 370546692
 size 640 480
**** END GRAPHICS REPORT ****
libpng warning: iCCP: known incorrect sRGB profile #REPEATED couple of times

real 1m14.118s
user 0m41.267s
sys 0m5.100s

$ ls -al output*
-rw-r--r-- 1 tibor tibor 33135351 jan 7 21:54 output_00.png
-rw-r--r-- 1 tibor tibor 34348444 jan 7 21:54 output_01.png
-rw-r--r-- 1 tibor tibor 4961263 jan 7 21:54 output.lua

---------------------------------------
$ time ./wl_make_texture_atlas 16384
........
real 0m33.660s
user 0m32.740s
sys 0m0.730s

ls -al output*
-rw-r--r-- 1 tibor tibor 440653 jan 7 21:58 output_00.png
-rw-r--r-- 1 tibor tibor 4983963 jan 7 21:58 output.lua

[bunnybot (widelandsofficial)]

Travis build 220 has changed state to: errored. Details: https://travis-ci.org/widelands/widelands/builds/100911902.

[kaputtnik (franku)]

The second is for graphic devs very hard. If one changes graphics, he has to put the atlas into a branch and upload for testing? This may cause heavy upload traffic. What is meant with "various resolutions"? Will this restrict the resolution options? F.e. no 800x600 resolution anymore?

The more i think of it the first one would be better. The main reason against this, is that the atlas has to be build on the users computer and needs some time... May there could be some kind of slideshow and/or descriptions of the game to bridge the time for the user while in the background the atlas is made?

[SirVer (sirver)]

Update: If you want te test the usage of the texture atlas in game, use this branch:
https://code.launchpad.net/~widelands-dev/widelands/use_image_cache

After you generated the texture atlas, you have to move the files into a directory called cache:
$ build/src/graphic/wl_make_texture_atlas 8192
$ mkdir cache
$ mv output* cache

Then start Widelands as usual.

> Can the building be part of installation process?

No, since it requires an OpenGL context to build the texture atlas. Therefore, a GUI is needed.

> I dont understand that stuff fully, but an user can pick various resolutions + windowed/fullscreen mode on his/her PC - no problem with this?

No, no problem with that.

> If one changes graphics, he has to put the atlas into a branch and upload for testing?

No, a graphic dev would need to run the program like described in this merge request - they could do that locally. The problem is that we'd need to build texture atlases at various sizes: 16384, 8192, 4096, 2048 and check all images in. If a dev changes one of the source images, all of these atlases would change again - this would yield huge changes to the bzr repo (since the images are big, 50MB).

> Will this restrict the resolution options? F.e. no 800x600 resolution anymore?

No, I meant the max texture resolution of graphics cards. The game will not loose any features, just gain performance.

> May there could be some kind of slideshow and/or descriptions of the game to bridge the time for the user while in the background the atlas is made?

That is hard - since all graphics need to go into the atlas. We could probably show a still image or some text, maybe also a progress bar.

[bunnybot (widelandsofficial)]

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

[kaputtnik (franku)]

> > May there could be some kind of slideshow and/or descriptions of the game to
> bridge the time for the user while in the background the atlas is made?
>
> That is hard - since all graphics need to go into the atlas. We could probably
> show a still image or some text, maybe also a progress bar.

Isn't it possible to exclude a folder with images from being included into the atlas?

We should consider to check all images if they are really used in the game or if we could use one image in different places. F.e. the world/resources/water4.png is afaik unused, do we need pics/hard.png AND pics/menu_tab_buildbig.png? Both are identical. Same goes for pics_attack_add_soldier.png, pics/attack_strongest.png and pics/menu_up_train.png... all three are identical and i don't know if all of them are used at all. Of course these pics are all very smal...

[SirVer (sirver)]

> Isn't it possible to exclude a folder with images from being included into the atlas?

yes. in fact, big pictures are already not included into the atlas, so there will still be a few standalone textures.

> Of course these pics are all very smal...

So they do not really matter that much anyways. We could get perfect optimization by compressing the texture atlas too, then duplicated images would be removed anyways.

[kaputtnik (franku)]

Values from another maschine:

Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz

time ./build/src/graphic/wl_make_texture_atlas 8192
Graphics: Try to set Videomode 1x1
Graphics: OpenGL: Version "3.0 Mesa 11.1.0"
Graphics: OpenGL: Double buffering enabled
Graphics: OpenGL: Max texture size: 8192

[...]

real 1m16.709s
user 1m2.800s
sys 0m10.137s

ls -l outpu*
-rw-r--r-- 1 kaputtnik kaputtnik 4961263 8. Jan 15:36 output.lua
-rw-r--r-- 1 kaputtnik kaputtnik 33675230 8. Jan 15:36 output_00.png
-rw-r--r-- 1 kaputtnik kaputtnik 35077200 8. Jan 15:36 output_01.png

This laptop uses only integrated GPU. I will try to activate the video card and test again.

[GunChleoc (gunchleoc)]

I like the idea of adding a special loading screen when Widelands is first run - e.g. the text could read "Optimizing Widelands images for first usage" or some such, so the user will know that they won't have to wait for this in the future.

We should then build the texture atlas only for the current resolution + fullscreen mode - the other resolutions could be calculated when the user switches the resolution, with a similar loading screen.

[SirVer (sirver)]

> I like the idea of adding a special loading screen when Widelands is first run - e.g. the text could read "Optimizing Widelands images for first usage" or some such, so the user will know that they won't have to wait for this in the future.

I'll look into that. I think that should be possible.

> We should then build the texture atlas only for the current resolution + fullscreen mode - the other resolutions could be calculated when the user switches the resolution, with a similar loading screen.

The in-game resolution and fullscreen/window is of no matter. We need to build the texture atlas for the max gl texture resolution of the graphics card we are running on. And of course for the current Widelands version - if the version change, graphics might have changed too, so we need to rebuild the atlas.

There have been many comments on this branch now. Can I merge it? The next branch will move the functionality of the binary into Widelands itself, so the code will live no, but the binary will go away soon.

[kaputtnik (franku)]

> There have been many comments on this branch now. Can I merge it? The next
> branch will move the functionality of the binary into Widelands itself, so the
> code will live no, but the binary will go away soon.

Nothing against your proposal, but we have seen that with every merge the last few weeks new bugs come up. There are great enhancements to widelands and until now, and i really want to have a feature freeze at current state. It is a lot of stuff to solve the already known bugs and i fear with every new feature the amount of bugs gets greater and a release gets far away.

But as said, i know you're a great programmer and your work would enhance widelands a lot. On the other side i have never heard that widelands is really slow (except long play games). So i think your proposal fixes problems that are not really there.

The changes which comes up with the render queue needs some fixing to images i think, Some of them looks now very sharp which is on side nice, on the other side some needs a bit tweeking, because they are too sharp. F.e. desert water has some sparkle in it, which now looks not very good imho. Changing those images and always make a new atlas sounds not good to me.

I think we should test the full texture atlas at a whole, f.e. with a "first run screen" and address it to build 20.

But in the end it's your decision to merge. You are the maintainer of widelands and i believe you know what you are doing :-)

[GunChleoc (gunchleoc)]

I had another idea regarding the loading screen: ui_fsmenu doesn't really need a performance enhancement, so we could not use the texture atlas in the fullscreen menus and generate it in the background, then finish loading it in the game/editor loading screens if necessary. I don't know the consequences for bug hunting/fixing of this though.

Another argument in favor of solution 1: modders can change images more easily. The texture atlas could also have a hash on file number/sizes/dates (maybe remember the file date on the newest file for each folder only?), so if a graphic dev changes something, the texture atlas is recalculated. Graphics devs will still need to wait, but they won't need to manually nuke the cache every time.

[kaputtnik (franku)]

Another question:

I use an extra datadir folder which contains some special images and that i use for testing purposes. What happens to the --datadir option when this get merged? Could i further use it for testing images?

[SirVer (sirver)]

[franku's concern about need for this change]
I play Widelands in fullscreen at 3440 x 1440. At that resolution, the game needs 90% of the single CPU it uses just to draw the screen. I want to add zooming in and out into Widelands, but that needs that performance even worse. On my wifes computer, Widelands noticeable stutters whenever the game loads a graphic from disk. I have been working on these performance improvements for over a year now - I think they are very important and I want to have them in build 19.

I understand your concerns about feature freeze and new bugs, but this is really important to me.

[background creation of texture atlas]
You want the mouse cursor in the texture atlas though, so that does not really work out. Also background generation is tricky business - what if some users jumps quickly through the menus and you need the atlas before you are ready. I'd rather not deal with these headaches.

[hash on the atlas]
You'd need to remember the hashes somewhere (in the lua file probably) and traverse all widelands data directories for all pictures and stat them on every game start - which is pretty slow already. Not as slow as building the cache, but probably ten seconds or so on a non Solid state disk. It would be an alternative to consider if the build_info() is too coarse grained.

> I use an extra datadir folder which contains some special images and that i use for testing purposes. What happens to the --datadir option when this get merged? Could i further use it for testing images?

Yes, but if you change an image, you'd need to manually run rm -rf ~/.widelands/cache, otherwise your new images would not be used.

[TiborB (tiborb95)]

I agree that this should be changed now - before build 19. This is performance improvement and game needs it badly.

But I also agree that we need to declare feature freeze ASAP and focus on feature freeze.

@SirVer, what else do you want to introduce before b19? I think your changes are last big changes before we enter the feature freeze.

What do you think?

[SirVer (sirver)]

> @SirVer, what else do you want to introduce before b19? I think your changes are last big changes before we enter the feature freeze.

I have one more smaller refactoring out that I want to get in [1]. I wanted to build zooming into the game (that was, what got me started on the whole GL improvements road), but I agree that this can wait till after build 19, so I delay that.

Once these branches are in, I'll focus on getting bugs fixed for b19 and I am fine with feature freezing. There are functional changes that need to happen but which I consider bug fixing - for example updating Eris, our Lua persistent library in third_party/ is a necessity to not break savegames in the future again.

[1] https://code.launchpad.net/~widelands-dev/widelands/split_overlay_manager/+merge/254496

[kaputtnik (franku)]

SirVer, i didn't know that you put so much time into this. And zooming would be a very nice thing to have, even if it comes in build 20 :-)

As i understand, merging just this branch is only the preparation for implementing the whole stuff and wouldn't change anything for now. So i am fine with merging.

Is there a decision which implementation (first or second) would be used? If we have a "first load for optimizing widelands" screen, would it be possible to have a slideshow/diashow in there? So we could may use some of the images from https://wl.widelands.org/wiki/Artwork/ with a small textbox containing some descriptions.

[SirVer (sirver)]

> As i understand, merging just this branch is only the preparation for implementing the whole stuff and wouldn't change anything for now. So i am fine with merging.

The full implementation is https://code.launchpad.net/~widelands-dev/widelands/use_image_cache. It implements solution 1. For now it only shows a static text and it freezes Widelands while loading, adding a slideshow or progress report is feasible, but more work.

I have a lot of testing feedback for this, but no code review comments. Could I get a lgtm for the code before merging?

[GunChleoc (gunchleoc)]

I will try to look at the code shoonish.

Regarding a feature freeze, there are 2 things that still need doing on my end:

1. Font renderer switchover: We have 1 wordwrap bug that needs fixing (https://bugs.launchpad.net/widelands/+bug/1530723), and after it has been fixed, I need to merge https://code.launchpad.net/~widelands-dev/widelands/multiline_textarea to speed up text rendering again. Then it will be just bug fixing.

2. Savegame compatibility is not done. We need to fix that up, because we want to keep compatibility again starting from builg 19 - we need to identify the packages that we can ignore with map loading and not load them (implement https://bugs.launchpad.net/widelands/+bug/1531463 and scrap https://code.launchpad.net/~widelands-dev/widelands/map_compatibility/+merge/276088).

I would also like the editor help in. It's not 100% slick (e.g. no resources help yet), but it does already contain some very valuable information and shouldn't introduce new bugs https://code.launchpad.net/~widelands-dev/widelands/editor_help

[TiborB (tiborb95)]

My understanding of feature freeze is that we will finish all opened work (f.e. branches waiting for merges, or ones that are really follow ups of what is opened now) but no brand new and unrelated changes/improvements will be started.

F.e. I am not going to make any changes to AI, there is only one branch waiting for merge review, this is what to be nice to have merged before release...

[GunChleoc (gunchleoc)]

Some small nits, otherwise LGTM

review: Approve

[SirVer (sirver)]

Adressed all comments and merged trunk. If everything passes on travis I'll merge this.

[SirVer (sirver)]

@bunnybot merge

=== modified file 'src/graphic/image_cache.cc'
--- src/graphic/image_cache.cc	2016-01-12 07:00:44 +0000
+++ src/graphic/image_cache.cc	2016-01-12 21:27:11 +0000
@@ -31,12 +31,6 @@
 #include "graphic/image_io.h"
 #include "graphic/texture.h"
 
-namespace  {
-
-constexpr int kBiggestAreaForCompactification = 250 * 250;
-
-}  // namespace
-
 ImageCache::ProxyImage::ProxyImage(std::unique_ptr<const Image> original_image)
    : image_(std::move(original_image)) {
 }
@@ -87,30 +81,3 @@
 	}
 	return it->second.get();
 }
-
-void ImageCache::compactify() {
-	TextureAtlas texture_atlas;
-
-	std::vector<std::string> hashes;
-	for (const auto& pair : images_) {
-		const auto& image = pair.second->image();
-		if (image.width() * image.height() > kBiggestAreaForCompactification) {
-			continue;
-		}
-
-		texture_atlas.add(image);
-		hashes.push_back(pair.first);
-	}
-
-	std::vector<std::unique_ptr<Texture>> new_textures;
-
-	// TODO(sirver): Limit the size of the texture atlas to a max GL texture
-	// size. This might return more than one packed image. Make sure that the
-	// code works also for small max texture sizes.
-	texture_atlases_.emplace_back(texture_atlas.pack(&new_textures));
-
-	assert(new_textures.size() == hashes.size());
-	for (size_t i = 0; i < hashes.size(); ++i) {
-		images_[hashes[i]]->set_image(std::move(new_textures[i]));
-	}
-}

=== modified file 'src/graphic/image_cache.h'
--- src/graphic/image_cache.h	2016-01-04 20:54:08 +0000
+++ src/graphic/image_cache.h	2016-01-12 21:27:11 +0000
@@ -55,10 +55,6 @@
 	// Returns true if the given hash is stored in the cache.
 	bool has(const std::string& hash) const;
 
-	// For debug only: Takes all images that are in the ImageCache right now and
-	// puts them into one huge texture atlas.
-	void compactify();
-
 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

=== modified file 'src/graphic/make_texture_atlas_main.cc'
--- src/graphic/make_texture_atlas_main.cc	2016-01-04 20:54:08 +0000
+++ src/graphic/make_texture_atlas_main.cc	2016-01-12 21:27:11 +0000
@@ -22,10 +22,12 @@
 #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
 
@@ -41,15 +43,39 @@
 
 namespace {
 
+// This is chosen so that all graphics for tribes are still well inside this
+// threshold, but not background pictures.
+constexpr int kMaxAreaForTextureAtlas = 240 * 240;
+
+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, std::string* input_directory)
+   int argc, char** argv, int* max_size)
 {
 	if (argc < 2) {
-		std::cout << "Usage: wl_make_texture_atlas <input directory>" << std::endl << std::endl
+		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;
 	}
-	*input_directory = argv[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;
 }
 
@@ -62,11 +88,121 @@
 	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");
+}
+
+// Recursively adds all images in 'directory' to 'ordered_images' and
+// 'handled_images' for which 'predicate' returns true. We keep track of the
+// images twice because we want to make sure that some end up in the same
+// (first) texture atlas, so we add them first and we use the set to know that
+// we already added an image.
+void find_images(const std::string& directory,
+                 std::unordered_set<std::string>* images,
+                 std::vector<std::string>* ordered_images) {
+	for (const std::string& filename : g_fs->list_directory(directory)) {
+		if (g_fs->is_directory(filename)) {
+			find_images(filename, images, ordered_images);
+			continue;
+		}
+		if (is_image(filename) && !images->count(filename)) {
+			images->insert(filename);
+			ordered_images->push_back(filename);
+		}
+	}
+}
+
+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");
+	}
+}
+
+// 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::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) {
+			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);
+	}
+
+	std::vector<std::unique_ptr<Texture>> texture_atlases;
+	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}));
+	}
+	return texture_atlases;
+}
+
 }  // namespace
 
 int main(int argc, char** argv) {
-	std::string input_directory;
-	if (parse_arguments(argc, argv, &input_directory))
+	int max_size;
+	if (parse_arguments(argc, argv, &max_size))
 		return 1;
 
 	if (SDL_Init(SDL_INIT_VIDEO) < 0) {
@@ -75,26 +211,63 @@
 	}
 	initialize();
 
-	std::vector<std::unique_ptr<Texture>> images;
-	std::unique_ptr<FileSystem> input_fs(&FileSystem::create(input_directory));
-	std::vector<std::string> png_filenames;
-	for (const std::string& filename : input_fs->list_directory("")) {
-		if (boost::ends_with(filename, ".png")) {
-			png_filenames.push_back(filename);
-			images.emplace_back(load_image(filename, input_fs.get()));
-		}
-	}
-
-	TextureAtlas atlas;
-	for (auto& image : images) {
-		atlas.add(*image);
-	}
-	std::vector<std::unique_ptr<Texture>> new_textures;
-	auto packed_texture = atlas.pack(&new_textures);
+
+	// 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::unordered_set<std::string> all_images;
+
+	// For terrain textures.
+	find_images("world/terrains", &all_images, &images_that_must_be_in_first_atlas);
+	// For flags and roads.
+	find_images("tribes/images", &all_images, &images_that_must_be_in_first_atlas);
+	// 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);
+	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("."));
-	std::unique_ptr<StreamWrite> sw(output_fs->open_stream_write("output.png"));
-	save_to_png(packed_texture.get(), sw.get(), ColorType::RGBA);
+	dump_result(pack_info, &texture_atlases, output_fs.get());
 
 	SDL_Quit();
 	return 0;

=== modified file 'src/graphic/texture_atlas.cc'
--- src/graphic/texture_atlas.cc	2016-01-04 20:54:08 +0000
+++ src/graphic/texture_atlas.cc	2016-01-12 21:27:11 +0000
@@ -68,22 +68,12 @@
 	return nullptr;
 }
 
-std::unique_ptr<Texture> TextureAtlas::pack(std::vector<std::unique_ptr<Texture>>* textures) {
-	if (blocks_.empty()) {
-		throw wexception("Called pack() without blocks.");
-	}
-
-	// Sort blocks by their biggest side length. This heuristically gives the
-	// best packing.
-	std::sort(blocks_.begin(), blocks_.end(), [](const Block& i, const Block& j) {
-		return std::max(i.texture->width(), i.texture->height()) >
-		       std::max(j.texture->width(), j.texture->height());
-	});
-
+std::unique_ptr<Texture> TextureAtlas::pack_as_many_as_possible(const int max_dimension,
+                                                                const int texture_atlas_index,
+                                                                std::vector<PackedTexture>* pack_info) {
 	std::unique_ptr<Node> root(
 	   new Node(Rect(0, 0, blocks_.begin()->texture->width(), blocks_.begin()->texture->height())));
 
-	// TODO(sirver): when growing, keep maximum size of gl textures in mind.
 	const auto grow_right = [&root](int delta_w) {
 		std::unique_ptr<Node> new_root(new Node(Rect(0, 0, root->r.w + delta_w, root->r.h)));
 		new_root->used = true;
@@ -100,6 +90,7 @@
 		root.reset(new_root.release());
 	};
 
+	std::vector<Block> packed, not_packed;
 	for (Block& block : blocks_) {
 		const int block_width = block.texture->width();
 		const int block_height = block.texture->height();
@@ -107,8 +98,10 @@
 		Node* fitting_node = find_node(root.get(), block_width, block_height);
 		if (fitting_node == nullptr) {
 			// Atlas is not big enough to contain this. Grow it and try again.
-			bool can_grow_down = (block_width <= root->r.w);
-			bool can_grow_right = (block_height <= root->r.h);
+			bool can_grow_down =
+			   (block_width <= root->r.w) && (block_height + root->r.h < max_dimension);
+			bool can_grow_right =
+			   (block_height <= root->r.h) && (block_width + root->r.w < max_dimension);
 
 			// Attempt to keep the texture square-ish.
 			bool should_grow_right = can_grow_right && (root->r.h >= root->r.w + block_width);
@@ -125,34 +118,59 @@
 			}
 			fitting_node = find_node(root.get(), block_width, block_height);
 		}
-		if (!fitting_node) {
-			throw wexception("Unable to fit node in texture atlas.");
+		if (fitting_node) {
+			fitting_node->split(block_width, block_height);
+			block.node = fitting_node;
+			packed.push_back(block);
+		} else {
+			not_packed.push_back(block);
 		}
-		fitting_node->split(block_width, block_height);
-		block.node = fitting_node;
 	}
 
-	std::unique_ptr<Texture> packed_texture(new Texture(root->r.w, root->r.h));
-	packed_texture->fill_rect(Rect(0, 0, root->r.w, root->r.h), RGBAColor(0, 0, 0, 0));
-
-	// Sort blocks by index so that they come back in the correct ordering.
-	std::sort(blocks_.begin(), blocks_.end(), [](const Block& i, const Block& j) {
-		return i.index < j.index;
-	});
-
-	const auto packed_texture_id = packed_texture->blit_data().texture_id;
-	for (Block& block : blocks_) {
-		packed_texture->blit(
+	std::unique_ptr<Texture> texture_atlas(new Texture(root->r.w, root->r.h));
+	texture_atlas->fill_rect(Rect(0, 0, root->r.w, root->r.h), RGBAColor(0, 0, 0, 0));
+
+	const auto packed_texture_id = texture_atlas->blit_data().texture_id;
+	for (Block& block : packed) {
+		texture_atlas->blit(
 		   Rect(block.node->r.x, block.node->r.y, block.texture->width(), block.texture->height()),
 		   *block.texture,
 		   Rect(0, 0, block.texture->width(), block.texture->height()),
 		   1.,
-		   BlendMode::UseAlpha);
-
-		textures->emplace_back(
-		   new Texture(packed_texture_id,
-		               Rect(block.node->r.origin(), block.texture->width(), block.texture->height()),
-		               root->r.w, root->r.h));
-	}
-	return packed_texture;
+		   BlendMode::Copy);
+
+		pack_info->emplace_back(PackedTexture(
+		   texture_atlas_index, block.index,
+		   std::unique_ptr<Texture>(new Texture(
+		      packed_texture_id,
+		      Rect(block.node->r.origin(), block.texture->width(), block.texture->height()),
+		      root->r.w, root->r.h))));
+	}
+	blocks_ = not_packed;
+	return texture_atlas;
+}
+
+void TextureAtlas::pack(const int max_dimension,
+		std::vector<std::unique_ptr<Texture>>* texture_atlases,
+		std::vector<PackedTexture>* pack_info) {
+	if (blocks_.empty()) {
+		throw wexception("Called pack() without blocks.");
+	}
+
+	// Sort blocks by their biggest side length. This heuristically gives the
+	// best packing.
+	std::sort(blocks_.begin(), blocks_.end(), [](const Block& i, const Block& j) {
+		return std::max(i.texture->width(), i.texture->height()) >
+		       std::max(j.texture->width(), j.texture->height());
+	});
+
+	while (blocks_.size()) {
+		texture_atlases->emplace_back(
+		   pack_as_many_as_possible(max_dimension, texture_atlases->size(), pack_info));
+	}
+
+	// Sort pack info by index so that they come back in the correct ordering.
+	std::sort(pack_info->begin(), pack_info->end(), [](const PackedTexture& i, const PackedTexture& j) {
+		return i.index_ < j.index_;
+	});
 }

=== modified file 'src/graphic/texture_atlas.h'
--- src/graphic/texture_atlas.h	2015-03-01 09:23:10 +0000
+++ src/graphic/texture_atlas.h	2016-01-12 21:27:11 +0000
@@ -30,6 +30,26 @@
 // http://codeincomplete.com/posts/2011/5/7/bin_packing/.
 class TextureAtlas {
 public:
+	struct PackedTexture {
+		PackedTexture() : texture_atlas(-1), texture(nullptr), index_(-1) {}
+
+		// The index of the returned texture atlas that contains this image.
+		int texture_atlas;
+
+		// The newly packed texture.
+		std::unique_ptr<Texture> texture;
+
+	private:
+		friend class TextureAtlas;
+
+		PackedTexture(int init_texture_atlas, int index, std::unique_ptr<Texture> init_texture)
+		   : texture_atlas(init_texture_atlas), texture(std::move(init_texture)), index_(index) {
+		}
+
+		// The position the images was 'add'()ed into the packing queue. Purely internal.
+		int index_;
+	};
+
 	TextureAtlas();
 
 	// Add 'texture' as one of the textures to be packed. Ownership is
@@ -37,10 +57,13 @@
 	// called.
 	void add(const Image& texture);
 
-	// Packs the textures and returns the packed texture. 'textures'
-	// contains the individual sub textures (that do not own their
-	// memory) in the order they have been added by 'add'.
-	std::unique_ptr<Texture> pack(std::vector<std::unique_ptr<Texture>>* textures);
+	// Packs the textures into as many texture atlases as needed, so that none
+	// of them will be larger than 'max_dimension' x 'max_dimension'. The
+	// returned 'textures' contains the individual sub textures (that do not own
+	// their memory) in the order they have been added by 'add'.
+	void pack(int max_dimension,
+	          std::vector<std::unique_ptr<Texture>>* texture_atlases,
+	          std::vector<PackedTexture>* textures);
 
 private:
 	struct Node {
@@ -57,14 +80,24 @@
 
 	struct Block {
 		Block(int init_index, const Image* init_texture)
-		   : index(init_index), texture(init_texture) {
+		   : index(init_index), texture(init_texture), done(false) {
 		}
 
+		// The index in the order the blocks have been added.
 		int index;
 		const Image* texture;
 		Node* node;
+
+		// True if this block has already been packed into a texture atlas.
+		bool done;
 	};
 
+	// Packs as many blocks from 'blocks_' that still have done = false into a
+	// fresh texture atlas that will not grow bigger than 'max_size' x
+	// 'max_size'.
+	std::unique_ptr<Texture> pack_as_many_as_possible(const int max_dimension,
+	                                                  const int texture_atlas_index,
+	                                                  std::vector<PackedTexture>* pack_info);
 	static Node* find_node(Node* root, int w, int h);
 
 	int next_index_;

=== modified file 'src/logic/map_objects/tribes/tribes.cc'
--- src/logic/map_objects/tribes/tribes.cc	2015-11-28 22:29:26 +0000
+++ src/logic/map_objects/tribes/tribes.cc	2016-01-12 21:27:11 +0000
@@ -360,17 +360,21 @@
 		}
 	}
 
-	std::vector<std::unique_ptr<Texture>> textures;
-	road_texture_ = ta.pack(&textures);
+	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(textures.at(next_texture_to_move++)));
+			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(textures.at(next_texture_to_move++)));
+			tribe->add_busy_road_texture(std::move(packed_texture.at(next_texture_to_move++).texture));
 		}
 	}
 }

=== modified file 'src/logic/map_objects/world/world.cc'
--- src/logic/map_objects/world/world.cc	2016-01-08 21:00:39 +0000
+++ src/logic/map_objects/world/world.cc	2016-01-12 21:27:11 +0000
@@ -72,14 +72,18 @@
 		}
 	}
 
-	std::vector<std::unique_ptr<Texture>> textures;
-	terrain_texture_ = ta.pack(&textures);
+	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(textures.at(next_texture_to_move++)));
+			terrain->add_texture(std::move(packed_texture.at(next_texture_to_move++).texture));
 		}
 	}
 }