Replace std::list to std::vector into tile.cpp (m_texture_trash) and move tile.hpp to src/client/

1 files changed, 1954 insertions, 0 deletions

diff --git a/src/client/tile.cpp b/src/client/tile.cpp
new file mode 100644
index 000000000..e5d02de7c
--- /dev/null
+++ b/src/client/tile.cpp
@@ -0,0 +1,1954 @@
+/*
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "tile.h"
+
+#include <ICameraSceneNode.h>
+#include "util/string.h"
+#include "util/container.h"
+#include "util/thread.h"
+#include "util/numeric.h"
+#include "irrlichttypes_extrabloated.h"
+#include "debug.h"
+#include "main.h" // for g_settings
+#include "filesys.h"
+#include "settings.h"
+#include "mesh.h"
+#include "log.h"
+#include "gamedef.h"
+#include "strfnd.h"
+#include "util/string.h" // for parseColorString()
+
+#ifdef __ANDROID__
+#include <GLES/gl.h>
+#endif
+
+/*
+	A cache from texture name to texture path
+*/
+MutexedMap<std::string, std::string> g_texturename_to_path_cache;
+
+/*
+	Replaces the filename extension.
+	eg:
+		std::string image = "a/image.png"
+		replace_ext(image, "jpg")
+		-> image = "a/image.jpg"
+	Returns true on success.
+*/
+static bool replace_ext(std::string &path, const char *ext)
+{
+	if (ext == NULL)
+		return false;
+	// Find place of last dot, fail if \ or / found.
+	s32 last_dot_i = -1;
+	for (s32 i=path.size()-1; i>=0; i--)
+	{
+		if (path[i] == '.')
+		{
+			last_dot_i = i;
+			break;
+		}
+
+		if (path[i] == '\\' || path[i] == '/')
+			break;
+	}
+	// If not found, return an empty string
+	if (last_dot_i == -1)
+		return false;
+	// Else make the new path
+	path = path.substr(0, last_dot_i+1) + ext;
+	return true;
+}
+
+/*
+	Find out the full path of an image by trying different filename
+	extensions.
+
+	If failed, return "".
+*/
+std::string getImagePath(std::string path)
+{
+	// A NULL-ended list of possible image extensions
+	const char *extensions[] = {
+		"png", "jpg", "bmp", "tga",
+		"pcx", "ppm", "psd", "wal", "rgb",
+		NULL
+	};
+	// If there is no extension, add one
+	if (removeStringEnd(path, extensions) == "")
+		path = path + ".png";
+	// Check paths until something is found to exist
+	const char **ext = extensions;
+	do{
+		bool r = replace_ext(path, *ext);
+		if (r == false)
+			return "";
+		if (fs::PathExists(path))
+			return path;
+	}
+	while((++ext) != NULL);
+
+	return "";
+}
+
+/*
+	Gets the path to a texture by first checking if the texture exists
+	in texture_path and if not, using the data path.
+
+	Checks all supported extensions by replacing the original extension.
+
+	If not found, returns "".
+
+	Utilizes a thread-safe cache.
+*/
+std::string getTexturePath(const std::string &filename)
+{
+	std::string fullpath = "";
+	/*
+		Check from cache
+	*/
+	bool incache = g_texturename_to_path_cache.get(filename, &fullpath);
+	if (incache)
+		return fullpath;
+
+	/*
+		Check from texture_path
+	*/
+	std::string texture_path = g_settings->get("texture_path");
+	if (texture_path != "")
+	{
+		std::string testpath = texture_path + DIR_DELIM + filename;
+		// Check all filename extensions. Returns "" if not found.
+		fullpath = getImagePath(testpath);
+	}
+
+	/*
+		Check from default data directory
+	*/
+	if (fullpath == "")
+	{
+		std::string base_path = porting::path_share + DIR_DELIM + "textures"
+				+ DIR_DELIM + "base" + DIR_DELIM + "pack";
+		std::string testpath = base_path + DIR_DELIM + filename;
+		// Check all filename extensions. Returns "" if not found.
+		fullpath = getImagePath(testpath);
+	}
+
+	// Add to cache (also an empty result is cached)
+	g_texturename_to_path_cache.set(filename, fullpath);
+
+	// Finally return it
+	return fullpath;
+}
+
+void clearTextureNameCache()
+{
+	g_texturename_to_path_cache.clear();
+}
+
+/*
+	Stores internal information about a texture.
+*/
+
+struct TextureInfo
+{
+	std::string name;
+	video::ITexture *texture;
+
+	TextureInfo(
+			const std::string &name_,
+			video::ITexture *texture_=NULL
+		):
+		name(name_),
+		texture(texture_)
+	{
+	}
+};
+
+/*
+	SourceImageCache: A cache used for storing source images.
+*/
+
+class SourceImageCache
+{
+public:
+	~SourceImageCache() {
+		for (std::map<std::string, video::IImage*>::iterator iter = m_images.begin();
+				iter != m_images.end(); iter++) {
+			iter->second->drop();
+		}
+		m_images.clear();
+	}
+	void insert(const std::string &name, video::IImage *img,
+			bool prefer_local, video::IVideoDriver *driver)
+	{
+		assert(img);
+		// Remove old image
+		std::map<std::string, video::IImage*>::iterator n;
+		n = m_images.find(name);
+		if (n != m_images.end()){
+			if (n->second)
+				n->second->drop();
+		}
+
+		video::IImage* toadd = img;
+		bool need_to_grab = true;
+
+		// Try to use local texture instead if asked to
+		if (prefer_local){
+			std::string path = getTexturePath(name);
+			if (path != ""){
+				video::IImage *img2 = driver->createImageFromFile(path.c_str());
+				if (img2){
+					toadd = img2;
+					need_to_grab = false;
+				}
+			}
+		}
+
+		if (need_to_grab)
+			toadd->grab();
+		m_images[name] = toadd;
+	}
+	video::IImage* get(const std::string &name)
+	{
+		std::map<std::string, video::IImage*>::iterator n;
+		n = m_images.find(name);
+		if (n != m_images.end())
+			return n->second;
+		return NULL;
+	}
+	// Primarily fetches from cache, secondarily tries to read from filesystem
+	video::IImage* getOrLoad(const std::string &name, IrrlichtDevice *device)
+	{
+		std::map<std::string, video::IImage*>::iterator n;
+		n = m_images.find(name);
+		if (n != m_images.end()){
+			n->second->grab(); // Grab for caller
+			return n->second;
+		}
+		video::IVideoDriver* driver = device->getVideoDriver();
+		std::string path = getTexturePath(name);
+		if (path == ""){
+			infostream<<"SourceImageCache::getOrLoad(): No path found for \""
+					<<name<<"\""<<std::endl;
+			return NULL;
+		}
+		infostream<<"SourceImageCache::getOrLoad(): Loading path \""<<path
+				<<"\""<<std::endl;
+		video::IImage *img = driver->createImageFromFile(path.c_str());
+
+		if (img){
+			m_images[name] = img;
+			img->grab(); // Grab for caller
+		}
+		return img;
+	}
+private:
+	std::map<std::string, video::IImage*> m_images;
+};
+
+/*
+	TextureSource
+*/
+
+class TextureSource : public IWritableTextureSource
+{
+public:
+	TextureSource(IrrlichtDevice *device);
+	virtual ~TextureSource();
+
+	/*
+		Example case:
+		Now, assume a texture with the id 1 exists, and has the name
+		"stone.png^mineral1".
+		Then a random thread calls getTextureId for a texture called
+		"stone.png^mineral1^crack0".
+		...Now, WTF should happen? Well:
+		- getTextureId strips off stuff recursively from the end until
+		  the remaining part is found, or nothing is left when
+		  something is stripped out
+
+		But it is slow to search for textures by names and modify them
+		like that?
+		- ContentFeatures is made to contain ids for the basic plain
+		  textures
+		- Crack textures can be slow by themselves, but the framework
+		  must be fast.
+
+		Example case #2:
+		- Assume a texture with the id 1 exists, and has the name
+		  "stone.png^mineral_coal.png".
+		- Now getNodeTile() stumbles upon a node which uses
+		  texture id 1, and determines that MATERIAL_FLAG_CRACK
+		  must be applied to the tile
+		- MapBlockMesh::animate() finds the MATERIAL_FLAG_CRACK and
+		  has received the current crack level 0 from the client. It
+		  finds out the name of the texture with getTextureName(1),
+		  appends "^crack0" to it and gets a new texture id with
+		  getTextureId("stone.png^mineral_coal.png^crack0").
+
+	*/
+
+	/*
+		Gets a texture id from cache or
+		- if main thread, generates the texture, adds to cache and returns id.
+		- if other thread, adds to request queue and waits for main thread.
+
+		The id 0 points to a NULL texture. It is returned in case of error.
+	*/
+	u32 getTextureId(const std::string &name);
+
+	// Finds out the name of a cached texture.
+	std::string getTextureName(u32 id);
+
+	/*
+		If texture specified by the name pointed by the id doesn't
+		exist, create it, then return the cached texture.
+
+		Can be called from any thread. If called from some other thread
+		and not found in cache, the call is queued to the main thread
+		for processing.
+	*/
+	video::ITexture* getTexture(u32 id);
+
+	video::ITexture* getTexture(const std::string &name, u32 *id);
+
+	// Returns a pointer to the irrlicht device
+	virtual IrrlichtDevice* getDevice()
+	{
+		return m_device;
+	}
+
+	bool isKnownSourceImage(const std::string &name)
+	{
+		bool is_known = false;
+		bool cache_found = m_source_image_existence.get(name, &is_known);
+		if (cache_found)
+			return is_known;
+		// Not found in cache; find out if a local file exists
+		is_known = (getTexturePath(name) != "");
+		m_source_image_existence.set(name, is_known);
+		return is_known;
+	}
+
+	// Processes queued texture requests from other threads.
+	// Shall be called from the main thread.
+	void processQueue();
+
+	// Insert an image into the cache without touching the filesystem.
+	// Shall be called from the main thread.
+	void insertSourceImage(const std::string &name, video::IImage *img);
+
+	// Rebuild images and textures from the current set of source images
+	// Shall be called from the main thread.
+	void rebuildImagesAndTextures();
+
+	// Render a mesh to a texture.
+	// Returns NULL if render-to-texture failed.
+	// Shall be called from the main thread.
+	video::ITexture* generateTextureFromMesh(
+			const TextureFromMeshParams &params);
+
+	// Generates an image from a full string like
+	// "stone.png^mineral_coal.png^[crack:1:0".
+	// Shall be called from the main thread.
+	video::IImage* generateImage(const std::string &name);
+
+	video::ITexture* getNormalTexture(const std::string &name);
+private:
+
+	// The id of the thread that is allowed to use irrlicht directly
+	threadid_t m_main_thread;
+	// The irrlicht device
+	IrrlichtDevice *m_device;
+
+	// Cache of source images
+	// This should be only accessed from the main thread
+	SourceImageCache m_sourcecache;
+
+	// Generate a texture
+	u32 generateTexture(const std::string &name);
+
+	// Generate image based on a string like "stone.png" or "[crack:1:0".
+	// if baseimg is NULL, it is created. Otherwise stuff is made on it.
+	bool generateImagePart(std::string part_of_name, video::IImage *& baseimg);
+
+	// Thread-safe cache of what source images are known (true = known)
+	MutexedMap<std::string, bool> m_source_image_existence;
+
+	// A texture id is index in this array.
+	// The first position contains a NULL texture.
+	std::vector<TextureInfo> m_textureinfo_cache;
+	// Maps a texture name to an index in the former.
+	std::map<std::string, u32> m_name_to_id;
+	// The two former containers are behind this mutex
+	JMutex m_textureinfo_cache_mutex;
+
+	// Queued texture fetches (to be processed by the main thread)
+	RequestQueue<std::string, u32, u8, u8> m_get_texture_queue;
+
+	// Textures that have been overwritten with other ones
+	// but can't be deleted because the ITexture* might still be used
+	std::vector<video::ITexture*> m_texture_trash;
+
+	// Cached settings needed for making textures from meshes
+	bool m_setting_trilinear_filter;
+	bool m_setting_bilinear_filter;
+	bool m_setting_anisotropic_filter;
+};
+
+IWritableTextureSource* createTextureSource(IrrlichtDevice *device)
+{
+	return new TextureSource(device);
+}
+
+TextureSource::TextureSource(IrrlichtDevice *device):
+		m_device(device)
+{
+	assert(m_device);
+
+	m_main_thread = get_current_thread_id();
+
+	// Add a NULL TextureInfo as the first index, named ""
+	m_textureinfo_cache.push_back(TextureInfo(""));
+	m_name_to_id[""] = 0;
+
+	// Cache some settings
+	// Note: Since this is only done once, the game must be restarted
+	// for these settings to take effect
+	m_setting_trilinear_filter = g_settings->getBool("trilinear_filter");
+	m_setting_bilinear_filter = g_settings->getBool("bilinear_filter");
+	m_setting_anisotropic_filter = g_settings->getBool("anisotropic_filter");
+}
+
+TextureSource::~TextureSource()
+{
+	video::IVideoDriver* driver = m_device->getVideoDriver();
+
+	unsigned int textures_before = driver->getTextureCount();
+
+	for (std::vector<TextureInfo>::iterator iter =
+			m_textureinfo_cache.begin();
+			iter != m_textureinfo_cache.end(); iter++)
+	{
+		//cleanup texture
+		if (iter->texture)
+			driver->removeTexture(iter->texture);
+	}
+	m_textureinfo_cache.clear();
+
+	for (std::vector<video::ITexture*>::iterator iter =
+			m_texture_trash.begin(); iter != m_texture_trash.end();
+			iter++) {
+		video::ITexture *t = *iter;
+
+		//cleanup trashed texture
+		driver->removeTexture(t);
+	}
+
+	infostream << "~TextureSource() "<< textures_before << "/"
+			<< driver->getTextureCount() << std::endl;
+}
+
+u32 TextureSource::getTextureId(const std::string &name)
+{
+	//infostream<<"getTextureId(): \""<<name<<"\""<<std::endl;
+
+	{
+		/*
+			See if texture already exists
+		*/
+		JMutexAutoLock lock(m_textureinfo_cache_mutex);
+		std::map<std::string, u32>::iterator n;
+		n = m_name_to_id.find(name);
+		if (n != m_name_to_id.end())
+		{
+			return n->second;
+		}
+	}
+
+	/*
+		Get texture
+	*/
+	if (get_current_thread_id() == m_main_thread)
+	{
+		return generateTexture(name);
+	}
+	else
+	{
+		infostream<<"getTextureId(): Queued: name=\""<<name<<"\""<<std::endl;
+
+		// We're gonna ask the result to be put into here
+		static ResultQueue<std::string, u32, u8, u8> result_queue;
+
+		// Throw a request in
+		m_get_texture_queue.add(name, 0, 0, &result_queue);
+
+		/*infostream<<"Waiting for texture from main thread, name=\""
+				<<name<<"\""<<std::endl;*/
+
+		try
+		{
+			while(true) {
+				// Wait result for a second
+				GetResult<std::string, u32, u8, u8>
+					result = result_queue.pop_front(1000);
+
+				if (result.key == name) {
+					return result.item;
+				}
+			}
+		}
+		catch(ItemNotFoundException &e)
+		{
+			errorstream<<"Waiting for texture " << name << " timed out."<<std::endl;
+			return 0;
+		}
+	}
+
+	infostream<<"getTextureId(): Failed"<<std::endl;
+
+	return 0;
+}
+
+// Draw an image on top of an another one, using the alpha channel of the
+// source image
+static void blit_with_alpha(video::IImage *src, video::IImage *dst,
+		v2s32 src_pos, v2s32 dst_pos, v2u32 size);
+
+// Like blit_with_alpha, but only modifies destination pixels that
+// are fully opaque
+static void blit_with_alpha_overlay(video::IImage *src, video::IImage *dst,
+		v2s32 src_pos, v2s32 dst_pos, v2u32 size);
+
+// Like blit_with_alpha overlay, but uses an int to calculate the ratio
+// and modifies any destination pixels that are not fully transparent
+static void blit_with_interpolate_overlay(video::IImage *src, video::IImage *dst,
+		v2s32 src_pos, v2s32 dst_pos, v2u32 size, int ratio);
+
+// Apply a mask to an image
+static void apply_mask(video::IImage *mask, video::IImage *dst,
+		v2s32 mask_pos, v2s32 dst_pos, v2u32 size);
+
+// Draw or overlay a crack
+static void draw_crack(video::IImage *crack, video::IImage *dst,
+		bool use_overlay, s32 frame_count, s32 progression,
+		video::IVideoDriver *driver);
+
+// Brighten image
+void brighten(video::IImage *image);
+// Parse a transform name
+u32 parseImageTransform(const std::string& s);
+// Apply transform to image dimension
+core::dimension2d<u32> imageTransformDimension(u32 transform, core::dimension2d<u32> dim);
+// Apply transform to image data
+void imageTransform(u32 transform, video::IImage *src, video::IImage *dst);
+
+/*
+	This method generates all the textures
+*/
+u32 TextureSource::generateTexture(const std::string &name)
+{
+	//infostream << "generateTexture(): name=\"" << name << "\"" << std::endl;
+
+	// Empty name means texture 0
+	if (name == "") {
+		infostream<<"generateTexture(): name is empty"<<std::endl;
+		return 0;
+	}
+
+	{
+		/*
+			See if texture already exists
+		*/
+		JMutexAutoLock lock(m_textureinfo_cache_mutex);
+		std::map<std::string, u32>::iterator n;
+		n = m_name_to_id.find(name);
+		if (n != m_name_to_id.end()) {
+			return n->second;
+		}
+	}
+
+	/*
+		Calling only allowed from main thread
+	*/
+	if (get_current_thread_id() != m_main_thread) {
+		errorstream<<"TextureSource::generateTexture() "
+				"called not from main thread"<<std::endl;
+		return 0;
+	}
+
+	video::IVideoDriver *driver = m_device->getVideoDriver();
+	assert(driver);
+
+	video::IImage *img = generateImage(name);
+
+	video::ITexture *tex = NULL;
+
+	if (img != NULL) {
+#ifdef __ANDROID__
+		img = Align2Npot2(img, driver);
+#endif
+		// Create texture from resulting image
+		tex = driver->addTexture(name.c_str(), img);
+		img->drop();
+	}
+
+	/*
+		Add texture to caches (add NULL textures too)
+	*/
+
+	JMutexAutoLock lock(m_textureinfo_cache_mutex);
+
+	u32 id = m_textureinfo_cache.size();
+	TextureInfo ti(name, tex);
+	m_textureinfo_cache.push_back(ti);
+	m_name_to_id[name] = id;
+
+	return id;
+}
+
+std::string TextureSource::getTextureName(u32 id)
+{
+	JMutexAutoLock lock(m_textureinfo_cache_mutex);
+
+	if (id >= m_textureinfo_cache.size())
+	{
+		errorstream<<"TextureSource::getTextureName(): id="<<id
+				<<" >= m_textureinfo_cache.size()="
+				<<m_textureinfo_cache.size()<<std::endl;
+		return "";
+	}
+
+	return m_textureinfo_cache[id].name;
+}
+
+video::ITexture* TextureSource::getTexture(u32 id)
+{
+	JMutexAutoLock lock(m_textureinfo_cache_mutex);
+
+	if (id >= m_textureinfo_cache.size())
+		return NULL;
+
+	return m_textureinfo_cache[id].texture;
+}
+
+video::ITexture* TextureSource::getTexture(const std::string &name, u32 *id)
+{
+	u32 actual_id = getTextureId(name);
+	if (id){
+		*id = actual_id;
+	}
+	return getTexture(actual_id);
+}
+
+void TextureSource::processQueue()
+{
+	/*
+		Fetch textures
+	*/
+	//NOTE this is only thread safe for ONE consumer thread!
+	if (!m_get_texture_queue.empty())
+	{
+		GetRequest<std::string, u32, u8, u8>
+				request = m_get_texture_queue.pop();
+
+		/*infostream<<"TextureSource::processQueue(): "
+				<<"got texture request with "
+				<<"name=\""<<request.key<<"\""
+				<<std::endl;*/
+
+		m_get_texture_queue.pushResult(request, generateTexture(request.key));
+	}
+}
+
+void TextureSource::insertSourceImage(const std::string &name, video::IImage *img)
+{
+	//infostream<<"TextureSource::insertSourceImage(): name="<<name<<std::endl;
+
+	assert(get_current_thread_id() == m_main_thread);
+
+	m_sourcecache.insert(name, img, true, m_device->getVideoDriver());
+	m_source_image_existence.set(name, true);
+}
+
+void TextureSource::rebuildImagesAndTextures()
+{
+	JMutexAutoLock lock(m_textureinfo_cache_mutex);
+
+	video::IVideoDriver* driver = m_device->getVideoDriver();
+	assert(driver != 0);
+
+	// Recreate textures
+	for (u32 i=0; i<m_textureinfo_cache.size(); i++){
+		TextureInfo *ti = &m_textureinfo_cache[i];
+		video::IImage *img = generateImage(ti->name);
+#ifdef __ANDROID__
+		img = Align2Npot2(img, driver);
+		assert(img->getDimension().Height == npot2(img->getDimension().Height));
+		assert(img->getDimension().Width == npot2(img->getDimension().Width));
+#endif
+		// Create texture from resulting image
+		video::ITexture *t = NULL;
+		if (img) {
+			t = driver->addTexture(ti->name.c_str(), img);
+			img->drop();
+		}
+		video::ITexture *t_old = ti->texture;
+		// Replace texture
+		ti->texture = t;
+
+		if (t_old)
+			m_texture_trash.push_back(t_old);
+	}
+}
+
+video::ITexture* TextureSource::generateTextureFromMesh(
+		const TextureFromMeshParams &params)
+{
+	video::IVideoDriver *driver = m_device->getVideoDriver();
+	assert(driver);
+
+#ifdef __ANDROID__
+	const GLubyte* renderstr = glGetString(GL_RENDERER);
+	std::string renderer((char*) renderstr);
+
+	// use no render to texture hack
+	if (
+		(renderer.find("Adreno") != std::string::npos) ||
+		(renderer.find("Mali") != std::string::npos) ||
+		(renderer.find("Immersion") != std::string::npos) ||
+		(renderer.find("Tegra") != std::string::npos) ||
+		g_settings->getBool("inventory_image_hack")
+		) {
+		// Get a scene manager
+		scene::ISceneManager *smgr_main = m_device->getSceneManager();
+		assert(smgr_main);
+		scene::ISceneManager *smgr = smgr_main->createNewSceneManager();
+		assert(smgr);
+
+		const float scaling = 0.2;
+
+		scene::IMeshSceneNode* meshnode =
+				smgr->addMeshSceneNode(params.mesh, NULL,
+						-1, v3f(0,0,0), v3f(0,0,0),
+						v3f(1.0 * scaling,1.0 * scaling,1.0 * scaling), true);
+		meshnode->setMaterialFlag(video::EMF_LIGHTING, true);
+		meshnode->setMaterialFlag(video::EMF_ANTI_ALIASING, true);
+		meshnode->setMaterialFlag(video::EMF_TRILINEAR_FILTER, m_setting_trilinear_filter);
+		meshnode->setMaterialFlag(video::EMF_BILINEAR_FILTER, m_setting_bilinear_filter);
+		meshnode->setMaterialFlag(video::EMF_ANISOTROPIC_FILTER, m_setting_anisotropic_filter);
+
+		scene::ICameraSceneNode* camera = smgr->addCameraSceneNode(0,
+				params.camera_position, params.camera_lookat);
+		// second parameter of setProjectionMatrix (isOrthogonal) is ignored
+		camera->setProjectionMatrix(params.camera_projection_matrix, false);
+
+		smgr->setAmbientLight(params.ambient_light);
+		smgr->addLightSceneNode(0,
+				params.light_position,
+				params.light_color,
+				params.light_radius*scaling);
+
+		core::dimension2d<u32> screen = driver->getScreenSize();
+
+		// Render scene
+		driver->beginScene(true, true, video::SColor(0,0,0,0));
+		driver->clearZBuffer();
+		smgr->drawAll();
+
+		core::dimension2d<u32> partsize(screen.Width * scaling,screen.Height * scaling);
+
+		irr::video::IImage* rawImage =
+				driver->createImage(irr::video::ECF_A8R8G8B8, partsize);
+
+		u8* pixels = static_cast<u8*>(rawImage->lock());
+		if (!pixels)
+		{
+			rawImage->drop();
+			return NULL;
+		}
+
+		core::rect<s32> source(
+				screen.Width /2 - (screen.Width  * (scaling / 2)),
+				screen.Height/2 - (screen.Height * (scaling / 2)),
+				screen.Width /2 + (screen.Width  * (scaling / 2)),
+				screen.Height/2 + (screen.Height * (scaling / 2))
+			);
+
+		glReadPixels(source.UpperLeftCorner.X, source.UpperLeftCorner.Y,
+				partsize.Width, partsize.Height, GL_RGBA,
+				GL_UNSIGNED_BYTE, pixels);
+
+		driver->endScene();
+
+		// Drop scene manager
+		smgr->drop();
+
+		unsigned int pixelcount = partsize.Width*partsize.Height;
+
+		u8* runptr = pixels;
+		for (unsigned int i=0; i < pixelcount; i++) {
+
+			u8 B = *runptr;
+			u8 G = *(runptr+1);
+			u8 R = *(runptr+2);
+			u8 A = *(runptr+3);
+
+			//BGRA -> RGBA
+			*runptr = R;
+			runptr ++;
+			*runptr = G;
+			runptr ++;
+			*runptr = B;
+			runptr ++;
+			*runptr = A;
+			runptr ++;
+		}
+
+		video::IImage* inventory_image =
+				driver->createImage(irr::video::ECF_A8R8G8B8, params.dim);
+
+		rawImage->copyToScaling(inventory_image);
+		rawImage->drop();
+
+		video::ITexture *rtt = driver->addTexture(params.rtt_texture_name.c_str(), inventory_image);
+		inventory_image->drop();
+
+		if (rtt == NULL) {
+			errorstream << "TextureSource::generateTextureFromMesh(): failed to recreate texture from image: " << params.rtt_texture_name << std::endl;
+			return NULL;
+		}
+
+		driver->makeColorKeyTexture(rtt, v2s32(0,0));
+
+		if (params.delete_texture_on_shutdown)
+			m_texture_trash.push_back(rtt);
+
+		return rtt;
+	}
+#endif
+
+	if (driver->queryFeature(video::EVDF_RENDER_TO_TARGET) == false)
+	{
+		static bool warned = false;
+		if (!warned)
+		{
+			errorstream<<"TextureSource::generateTextureFromMesh(): "
+				<<"EVDF_RENDER_TO_TARGET not supported."<<std::endl;
+			warned = true;
+		}
+		return NULL;
+	}
+
+	// Create render target texture
+	video::ITexture *rtt = driver->addRenderTargetTexture(
+			params.dim, params.rtt_texture_name.c_str(),
+			video::ECF_A8R8G8B8);
+	if (rtt == NULL)
+	{
+		errorstream<<"TextureSource::generateTextureFromMesh(): "
+			<<"addRenderTargetTexture returned NULL."<<std::endl;
+		return NULL;
+	}
+
+	// Set render target
+	if (!driver->setRenderTarget(rtt, false, true, video::SColor(0,0,0,0))) {
+		driver->removeTexture(rtt);
+		errorstream<<"TextureSource::generateTextureFromMesh(): "
+			<<"failed to set render target"<<std::endl;
+		return NULL;
+	}
+
+	// Get a scene manager
+	scene::ISceneManager *smgr_main = m_device->getSceneManager();
+	assert(smgr_main);
+	scene::ISceneManager *smgr = smgr_main->createNewSceneManager();
+	assert(smgr);
+
+	scene::IMeshSceneNode* meshnode =
+			smgr->addMeshSceneNode(params.mesh, NULL,
+					-1, v3f(0,0,0), v3f(0,0,0), v3f(1,1,1), true);
+	meshnode->setMaterialFlag(video::EMF_LIGHTING, true);
+	meshnode->setMaterialFlag(video::EMF_ANTI_ALIASING, true);
+	meshnode->setMaterialFlag(video::EMF_TRILINEAR_FILTER, m_setting_trilinear_filter);
+	meshnode->setMaterialFlag(video::EMF_BILINEAR_FILTER, m_setting_bilinear_filter);
+	meshnode->setMaterialFlag(video::EMF_ANISOTROPIC_FILTER, m_setting_anisotropic_filter);
+
+	scene::ICameraSceneNode* camera = smgr->addCameraSceneNode(0,
+			params.camera_position, params.camera_lookat);
+	// second parameter of setProjectionMatrix (isOrthogonal) is ignored
+	camera->setProjectionMatrix(params.camera_projection_matrix, false);
+
+	smgr->setAmbientLight(params.ambient_light);
+	smgr->addLightSceneNode(0,
+			params.light_position,
+			params.light_color,
+			params.light_radius);
+
+	// Render scene
+	driver->beginScene(true, true, video::SColor(0,0,0,0));
+	smgr->drawAll();
+	driver->endScene();
+
+	// Drop scene manager
+	smgr->drop();
+
+	// Unset render target
+	driver->setRenderTarget(0, false, true, 0);
+
+	if (params.delete_texture_on_shutdown)
+		m_texture_trash.push_back(rtt);
+
+	return rtt;
+}
+
+video::IImage* TextureSource::generateImage(const std::string &name)
+{
+	/*
+		Get the base image
+	*/
+
+	const char separator = '^';
+	const char paren_open = '(';
+	const char paren_close = ')';
+
+	// Find last separator in the name
+	s32 last_separator_pos = -1;
+	u8 paren_bal = 0;
+	for (s32 i = name.size() - 1; i >= 0; i--) {
+		switch(name[i]) {
+		case separator:
+			if (paren_bal == 0) {
+				last_separator_pos = i;
+				i = -1; // break out of loop
+			}
+			break;
+		case paren_open:
+			if (paren_bal == 0) {
+				errorstream << "generateImage(): unbalanced parentheses"
+						<< "(extranous '(') while generating texture \""
+						<< name << "\"" << std::endl;
+				return NULL;
+			}
+			paren_bal--;
+			break;
+		case paren_close:
+			paren_bal++;
+			break;
+		default:
+			break;
+		}
+	}
+	if (paren_bal > 0) {
+		errorstream << "generateImage(): unbalanced parentheses"
+				<< "(missing matching '(') while generating texture \""
+				<< name << "\"" << std::endl;
+		return NULL;
+	}
+
+
+	video::IImage *baseimg = NULL;
+
+	/*
+		If separator was found, make the base image
+		using a recursive call.
+	*/
+	if (last_separator_pos != -1) {
+		baseimg = generateImage(name.substr(0, last_separator_pos));
+	}
+
+
+	video::IVideoDriver* driver = m_device->getVideoDriver();
+	assert(driver);
+
+	/*
+		Parse out the last part of the name of the image and act
+		according to it
+	*/
+
+	std::string last_part_of_name = name.substr(last_separator_pos + 1);
+
+	/* 
+		If this name is enclosed in parentheses, generate it
+		and blit it onto the base image
+	*/
+	if (last_part_of_name[0] == paren_open
+			&& last_part_of_name[last_part_of_name.size() - 1] == paren_close) {
+		std::string name2 = last_part_of_name.substr(1,
+				last_part_of_name.size() - 2);
+		video::IImage *tmp = generateImage(name2);
+		if (!tmp) {
+			errorstream << "generateImage(): "
+				"Failed to generate \"" << name2 << "\""
+				<< std::endl;
+			return NULL;
+		}
+		core::dimension2d<u32> dim = tmp->getDimension();
+		if (!baseimg)
+			baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
+		blit_with_alpha(tmp, baseimg, v2s32(0, 0), v2s32(0, 0), dim);
+		tmp->drop();
+	} else if (!generateImagePart(last_part_of_name, baseimg)) {
+		// Generate image according to part of name
+		errorstream << "generateImage(): "
+				"Failed to generate \"" << last_part_of_name << "\""
+				<< std::endl;
+	}
+
+	// If no resulting image, print a warning
+	if (baseimg == NULL) {
+		errorstream << "generateImage(): baseimg is NULL (attempted to"
+				" create texture \"" << name << "\")" << std::endl;
+	}
+
+	return baseimg;
+}
+
+#ifdef __ANDROID__
+#include <GLES/gl.h>
+/**
+ * Check and align image to npot2 if required by hardware
+ * @param image image to check for npot2 alignment
+ * @param driver driver to use for image operations
+ * @return image or copy of image aligned to npot2
+ */
+video::IImage * Align2Npot2(video::IImage * image,
+		video::IVideoDriver* driver)
+{
+	if (image == NULL) {
+		return image;
+	}
+
+	core::dimension2d<u32> dim = image->getDimension();
+
+	std::string extensions = (char*) glGetString(GL_EXTENSIONS);
+	if (extensions.find("GL_OES_texture_npot") != std::string::npos) {
+		return image;
+	}
+
+	unsigned int height = npot2(dim.Height);
+	unsigned int width  = npot2(dim.Width);
+
+	if ((dim.Height == height) &&
+			(dim.Width == width)) {
+		return image;
+	}
+
+	if (dim.Height > height) {
+		height *= 2;
+	}
+
+	if (dim.Width > width) {
+		width *= 2;
+	}
+
+	video::IImage *targetimage =
+			driver->createImage(video::ECF_A8R8G8B8,
+					core::dimension2d<u32>(width, height));
+
+	if (targetimage != NULL) {
+		image->copyToScaling(targetimage);
+	}
+	image->drop();
+	return targetimage;
+}
+
+#endif
+
+bool TextureSource::generateImagePart(std::string part_of_name,
+		video::IImage *& baseimg)
+{
+	video::IVideoDriver* driver = m_device->getVideoDriver();
+	assert(driver);
+
+	// Stuff starting with [ are special commands
+	if (part_of_name.size() == 0 || part_of_name[0] != '[')
+	{
+		video::IImage *image = m_sourcecache.getOrLoad(part_of_name, m_device);
+#ifdef __ANDROID__
+		image = Align2Npot2(image, driver);
+#endif
+		if (image == NULL) {
+			if (part_of_name != "") {
+				if (part_of_name.find("_normal.png") == std::string::npos){
+					errorstream<<"generateImage(): Could not load image \""
+						<<part_of_name<<"\""<<" while building texture"<<std::endl;
+					errorstream<<"generateImage(): Creating a dummy"
+						<<" image for \""<<part_of_name<<"\""<<std::endl;
+				} else {
+					infostream<<"generateImage(): Could not load normal map \""
+						<<part_of_name<<"\""<<std::endl;
+					infostream<<"generateImage(): Creating a dummy"
+						<<" normal map for \""<<part_of_name<<"\""<<std::endl;
+				}
+			}
+
+			// Just create a dummy image
+			//core::dimension2d<u32> dim(2,2);
+			core::dimension2d<u32> dim(1,1);
+			image = driver->createImage(video::ECF_A8R8G8B8, dim);
+			assert(image);
+			/*image->setPixel(0,0, video::SColor(255,255,0,0));
+			image->setPixel(1,0, video::SColor(255,0,255,0));
+			image->setPixel(0,1, video::SColor(255,0,0,255));
+			image->setPixel(1,1, video::SColor(255,255,0,255));*/
+			image->setPixel(0,0, video::SColor(255,myrand()%256,
+					myrand()%256,myrand()%256));
+			/*image->setPixel(1,0, video::SColor(255,myrand()%256,
+					myrand()%256,myrand()%256));
+			image->setPixel(0,1, video::SColor(255,myrand()%256,
+					myrand()%256,myrand()%256));
+			image->setPixel(1,1, video::SColor(255,myrand()%256,
+					myrand()%256,myrand()%256));*/
+		}
+
+		// If base image is NULL, load as base.
+		if (baseimg == NULL)
+		{
+			//infostream<<"Setting "<<part_of_name<<" as base"<<std::endl;
+			/*
+				Copy it this way to get an alpha channel.
+				Otherwise images with alpha cannot be blitted on
+				images that don't have alpha in the original file.
+			*/
+			core::dimension2d<u32> dim = image->getDimension();
+			baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
+			image->copyTo(baseimg);
+		}
+		// Else blit on base.
+		else
+		{
+			//infostream<<"Blitting "<<part_of_name<<" on base"<<std::endl;
+			// Size of the copied area
+			core::dimension2d<u32> dim = image->getDimension();
+			//core::dimension2d<u32> dim(16,16);
+			// Position to copy the blitted to in the base image
+			core::position2d<s32> pos_to(0,0);
+			// Position to copy the blitted from in the blitted image
+			core::position2d<s32> pos_from(0,0);
+			// Blit
+			/*image->copyToWithAlpha(baseimg, pos_to,
+					core::rect<s32>(pos_from, dim),
+					video::SColor(255,255,255,255),
+					NULL);*/
+			blit_with_alpha(image, baseimg, pos_from, pos_to, dim);
+		}
+		//cleanup
+		image->drop();
+	}
+	else
+	{
+		// A special texture modification
+
+		/*infostream<<"generateImage(): generating special "
+				<<"modification \""<<part_of_name<<"\""
+				<<std::endl;*/
+
+		/*
+			[crack:N:P
+			[cracko:N:P
+			Adds a cracking texture
+			N = animation frame count, P = crack progression
+		*/
+		if (part_of_name.substr(0,6) == "[crack")
+		{
+			if (baseimg == NULL) {
+				errorstream<<"generateImagePart(): baseimg == NULL "
+						<<"for part_of_name=\""<<part_of_name
+						<<"\", cancelling."<<std::endl;
+				return false;
+			}
+
+			// Crack image number and overlay option
+			bool use_overlay = (part_of_name[6] == 'o');
+			Strfnd sf(part_of_name);
+			sf.next(":");
+			s32 frame_count = stoi(sf.next(":"));
+			s32 progression = stoi(sf.next(":"));
+
+			/*
+				Load crack image.
+
+				It is an image with a number of cracking stages
+				horizontally tiled.
+			*/
+			video::IImage *img_crack = m_sourcecache.getOrLoad(
+					"crack_anylength.png", m_device);
+
+			if (img_crack && progression >= 0)
+			{
+				draw_crack(img_crack, baseimg,
+						use_overlay, frame_count,
+						progression, driver);
+				img_crack->drop();
+			}
+		}
+		/*
+			[combine:WxH:X,Y=filename:X,Y=filename2
+			Creates a bigger texture from an amount of smaller ones
+		*/
+		else if (part_of_name.substr(0,8) == "[combine")
+		{
+			Strfnd sf(part_of_name);
+			sf.next(":");
+			u32 w0 = stoi(sf.next("x"));
+			u32 h0 = stoi(sf.next(":"));
+			//infostream<<"combined w="<<w0<<" h="<<h0<<std::endl;
+			core::dimension2d<u32> dim(w0,h0);
+			if (baseimg == NULL) {
+				baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
+				baseimg->fill(video::SColor(0,0,0,0));
+			}
+			while (sf.atend() == false) {
+				u32 x = stoi(sf.next(","));
+				u32 y = stoi(sf.next("="));
+				std::string filename = sf.next(":");
+				infostream<<"Adding \""<<filename
+						<<"\" to combined ("<<x<<","<<y<<")"
+						<<std::endl;
+				video::IImage *img = m_sourcecache.getOrLoad(filename, m_device);
+				if (img) {
+					core::dimension2d<u32> dim = img->getDimension();
+					infostream<<"Size "<<dim.Width
+							<<"x"<<dim.Height<<std::endl;
+					core::position2d<s32> pos_base(x, y);
+					video::IImage *img2 =
+							driver->createImage(video::ECF_A8R8G8B8, dim);
+					img->copyTo(img2);
+					img->drop();
+					/*img2->copyToWithAlpha(baseimg, pos_base,
+							core::rect<s32>(v2s32(0,0), dim),
+							video::SColor(255,255,255,255),
+							NULL);*/
+					blit_with_alpha(img2, baseimg, v2s32(0,0), pos_base, dim);
+					img2->drop();
+				} else {
+					errorstream << "generateImagePart(): Failed to load image \""
+						<< filename << "\" for [combine" << std::endl;
+				}
+			}
+		}
+		/*
+			"[brighten"
+		*/
+		else if (part_of_name.substr(0,9) == "[brighten")
+		{
+			if (baseimg == NULL) {
+				errorstream<<"generateImagePart(): baseimg==NULL "
+						<<"for part_of_name=\""<<part_of_name
+						<<"\", cancelling."<<std::endl;
+				return false;
+			}
+
+			brighten(baseimg);
+		}
+		/*
+			"[noalpha"
+			Make image completely opaque.
+			Used for the leaves texture when in old leaves mode, so
+			that the transparent parts don't look completely black
+			when simple alpha channel is used for rendering.
+		*/
+		else if (part_of_name.substr(0,8) == "[noalpha")
+		{
+			if (baseimg == NULL){
+				errorstream<<"generateImagePart(): baseimg==NULL "
+						<<"for part_of_name=\""<<part_of_name
+						<<"\", cancelling."<<std::endl;
+				return false;
+			}
+
+			core::dimension2d<u32> dim = baseimg->getDimension();
+
+			// Set alpha to full
+			for (u32 y=0; y<dim.Height; y++)
+			for (u32 x=0; x<dim.Width; x++)
+			{
+				video::SColor c = baseimg->getPixel(x,y);
+				c.setAlpha(255);
+				baseimg->setPixel(x,y,c);
+			}
+		}
+		/*
+			"[makealpha:R,G,B"
+			Convert one color to transparent.
+		*/
+		else if (part_of_name.substr(0,11) == "[makealpha:")
+		{
+			if (baseimg == NULL) {
+				errorstream<<"generateImagePart(): baseimg == NULL "
+						<<"for part_of_name=\""<<part_of_name
+						<<"\", cancelling."<<std::endl;
+				return false;
+			}
+
+			Strfnd sf(part_of_name.substr(11));
+			u32 r1 = stoi(sf.next(","));
+			u32 g1 = stoi(sf.next(","));
+			u32 b1 = stoi(sf.next(""));
+			std::string filename = sf.next("");
+
+			core::dimension2d<u32> dim = baseimg->getDimension();
+
+			/*video::IImage *oldbaseimg = baseimg;
+			baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
+			oldbaseimg->copyTo(baseimg);
+			oldbaseimg->drop();*/
+
+			// Set alpha to full
+			for (u32 y=0; y<dim.Height; y++)
+			for (u32 x=0; x<dim.Width; x++)
+			{
+				video::SColor c = baseimg->getPixel(x,y);
+				u32 r = c.getRed();
+				u32 g = c.getGreen();
+				u32 b = c.getBlue();
+				if (!(r == r1 && g == g1 && b == b1))
+					continue;
+				c.setAlpha(0);
+				baseimg->setPixel(x,y,c);
+			}
+		}
+		/*
+			"[transformN"
+			Rotates and/or flips the image.
+
+			N can be a number (between 0 and 7) or a transform name.
+			Rotations are counter-clockwise.
+			0  I      identity
+			1  R90    rotate by 90 degrees
+			2  R180   rotate by 180 degrees
+			3  R270   rotate by 270 degrees
+			4  FX     flip X
+			5  FXR90  flip X then rotate by 90 degrees
+			6  FY     flip Y
+			7  FYR90  flip Y then rotate by 90 degrees
+
+			Note: Transform names can be concatenated to produce
+			their product (applies the first then the second).
+			The resulting transform will be equivalent to one of the
+			eight existing ones, though (see: dihedral group).
+		*/
+		else if (part_of_name.substr(0,10) == "[transform")
+		{
+			if (baseimg == NULL) {
+				errorstream<<"generateImagePart(): baseimg == NULL "
+						<<"for part_of_name=\""<<part_of_name
+						<<"\", cancelling."<<std::endl;
+				return false;
+			}
+
+			u32 transform = parseImageTransform(part_of_name.substr(10));
+			core::dimension2d<u32> dim = imageTransformDimension(
+					transform, baseimg->getDimension());
+			video::IImage *image = driver->createImage(
+					baseimg->getColorFormat(), dim);
+			assert(image);
+			imageTransform(transform, baseimg, image);
+			baseimg->drop();
+			baseimg = image;
+		}
+		/*
+			[inventorycube{topimage{leftimage{rightimage
+			In every subimage, replace ^ with &.
+			Create an "inventory cube".
+			NOTE: This should be used only on its own.
+			Example (a grass block (not actually used in game):
+			"[inventorycube{grass.png{mud.png&grass_side.png{mud.png&grass_side.png"
+		*/
+		else if (part_of_name.substr(0,14) == "[inventorycube")
+		{
+			if (baseimg != NULL){
+				errorstream<<"generateImagePart(): baseimg != NULL "
+						<<"for part_of_name=\""<<part_of_name
+						<<"\", cancelling."<<std::endl;
+				return false;
+			}
+
+			str_replace(part_of_name, '&', '^');
+			Strfnd sf(part_of_name);
+			sf.next("{");
+			std::string imagename_top = sf.next("{");
+			std::string imagename_left = sf.next("{");
+			std::string imagename_right = sf.next("{");
+
+			// Generate images for the faces of the cube
+			video::IImage *img_top = generateImage(imagename_top);
+			video::IImage *img_left = generateImage(imagename_left);
+			video::IImage *img_right = generateImage(imagename_right);
+
+			if (img_top == NULL || img_left == NULL || img_right == NULL) {
+				errorstream << "generateImagePart(): Failed to create textures"
+						<< " for inventorycube \"" << part_of_name << "\""
+						<< std::endl;
+				baseimg = generateImage(imagename_top);
+				return true;
+			}
+
+#ifdef __ANDROID__
+			assert(img_top->getDimension().Height == npot2(img_top->getDimension().Height));
+			assert(img_top->getDimension().Width == npot2(img_top->getDimension().Width));
+
+			assert(img_left->getDimension().Height == npot2(img_left->getDimension().Height));
+			assert(img_left->getDimension().Width == npot2(img_left->getDimension().Width));
+
+			assert(img_right->getDimension().Height == npot2(img_right->getDimension().Height));
+			assert(img_right->getDimension().Width == npot2(img_right->getDimension().Width));
+#endif
+
+			// Create textures from images
+			video::ITexture *texture_top = driver->addTexture(
+					(imagename_top + "__temp__").c_str(), img_top);
+			video::ITexture *texture_left = driver->addTexture(
+					(imagename_left + "__temp__").c_str(), img_left);
+			video::ITexture *texture_right = driver->addTexture(
+					(imagename_right + "__temp__").c_str(), img_right);
+			assert(texture_top && texture_left && texture_right);
+
+			// Drop images
+			img_top->drop();
+			img_left->drop();
+			img_right->drop();
+
+			/*
+				Draw a cube mesh into a render target texture
+			*/
+			scene::IMesh* cube = createCubeMesh(v3f(1, 1, 1));
+			setMeshColor(cube, video::SColor(255, 255, 255, 255));
+			cube->getMeshBuffer(0)->getMaterial().setTexture(0, texture_top);
+			cube->getMeshBuffer(1)->getMaterial().setTexture(0, texture_top);
+			cube->getMeshBuffer(2)->getMaterial().setTexture(0, texture_right);
+			cube->getMeshBuffer(3)->getMaterial().setTexture(0, texture_right);
+			cube->getMeshBuffer(4)->getMaterial().setTexture(0, texture_left);
+			cube->getMeshBuffer(5)->getMaterial().setTexture(0, texture_left);
+
+			TextureFromMeshParams params;
+			params.mesh = cube;
+			params.dim.set(64, 64);
+			params.rtt_texture_name = part_of_name + "_RTT";
+			// We will delete the rtt texture ourselves
+			params.delete_texture_on_shutdown = false;
+			params.camera_position.set(0, 1.0, -1.5);
+			params.camera_position.rotateXZBy(45);
+			params.camera_lookat.set(0, 0, 0);
+			// Set orthogonal projection
+			params.camera_projection_matrix.buildProjectionMatrixOrthoLH(
+					1.65, 1.65, 0, 100);
+
+			params.ambient_light.set(1.0, 0.2, 0.2, 0.2);
+			params.light_position.set(10, 100, -50);
+			params.light_color.set(1.0, 0.5, 0.5, 0.5);
+			params.light_radius = 1000;
+
+			video::ITexture *rtt = generateTextureFromMesh(params);
+
+			// Drop mesh
+			cube->drop();
+
+			// Free textures
+			driver->removeTexture(texture_top);
+			driver->removeTexture(texture_left);
+			driver->removeTexture(texture_right);
+
+			if (rtt == NULL) {
+				baseimg = generateImage(imagename_top);
+				return true;
+			}
+
+			// Create image of render target
+			video::IImage *image = driver->createImage(rtt, v2s32(0, 0), params.dim);
+			assert(image);
+
+			// Cleanup texture
+			driver->removeTexture(rtt);
+
+			baseimg = driver->createImage(video::ECF_A8R8G8B8, params.dim);
+
+			if (image) {
+				image->copyTo(baseimg);
+				image->drop();
+			}
+		}
+		/*
+			[lowpart:percent:filename
+			Adds the lower part of a texture
+		*/
+		else if (part_of_name.substr(0,9) == "[lowpart:")
+		{
+			Strfnd sf(part_of_name);
+			sf.next(":");
+			u32 percent = stoi(sf.next(":"));
+			std::string filename = sf.next(":");
+			//infostream<<"power part "<<percent<<"%% of "<<filename<<std::endl;
+
+			if (baseimg == NULL)
+				baseimg = driver->createImage(video::ECF_A8R8G8B8, v2u32(16,16));
+			video::IImage *img = m_sourcecache.getOrLoad(filename, m_device);
+			if (img)
+			{
+				core::dimension2d<u32> dim = img->getDimension();
+				core::position2d<s32> pos_base(0, 0);
+				video::IImage *img2 =
+						driver->createImage(video::ECF_A8R8G8B8, dim);
+				img->copyTo(img2);
+				img->drop();
+				core::position2d<s32> clippos(0, 0);
+				clippos.Y = dim.Height * (100-percent) / 100;
+				core::dimension2d<u32> clipdim = dim;
+				clipdim.Height = clipdim.Height * percent / 100 + 1;
+				core::rect<s32> cliprect(clippos, clipdim);
+				img2->copyToWithAlpha(baseimg, pos_base,
+						core::rect<s32>(v2s32(0,0), dim),
+						video::SColor(255,255,255,255),
+						&cliprect);
+				img2->drop();
+			}
+		}
+		/*
+			[verticalframe:N:I
+			Crops a frame of a vertical animation.
+			N = frame count, I = frame index
+		*/
+		else if (part_of_name.substr(0,15) == "[verticalframe:")
+		{
+			Strfnd sf(part_of_name);
+			sf.next(":");
+			u32 frame_count = stoi(sf.next(":"));
+			u32 frame_index = stoi(sf.next(":"));
+
+			if (baseimg == NULL){
+				errorstream<<"generateImagePart(): baseimg != NULL "
+						<<"for part_of_name=\""<<part_of_name
+						<<"\", cancelling."<<std::endl;
+				return false;
+			}
+
+			v2u32 frame_size = baseimg->getDimension();
+			frame_size.Y /= frame_count;
+
+			video::IImage *img = driver->createImage(video::ECF_A8R8G8B8,
+					frame_size);
+			if (!img){
+				errorstream<<"generateImagePart(): Could not create image "
+						<<"for part_of_name=\""<<part_of_name
+						<<"\", cancelling."<<std::endl;
+				return false;
+			}
+
+			// Fill target image with transparency
+			img->fill(video::SColor(0,0,0,0));
+
+			core::dimension2d<u32> dim = frame_size;
+			core::position2d<s32> pos_dst(0, 0);
+			core::position2d<s32> pos_src(0, frame_index * frame_size.Y);
+			baseimg->copyToWithAlpha(img, pos_dst,
+					core::rect<s32>(pos_src, dim),
+					video::SColor(255,255,255,255),
+					NULL);
+			// Replace baseimg
+			baseimg->drop();
+			baseimg = img;
+		}
+		/*
+			[mask:filename
+			Applies a mask to an image
+		*/
+		else if (part_of_name.substr(0,6) == "[mask:")
+		{
+			if (baseimg == NULL) {
+				errorstream << "generateImage(): baseimg == NULL "
+						<< "for part_of_name=\"" << part_of_name
+						<< "\", cancelling." << std::endl;
+				return false;
+			}
+			Strfnd sf(part_of_name);
+			sf.next(":");
+			std::string filename = sf.next(":");
+
+			video::IImage *img = m_sourcecache.getOrLoad(filename, m_device);
+			if (img) {
+				apply_mask(img, baseimg, v2s32(0, 0), v2s32(0, 0),
+						img->getDimension());
+			} else {
+				errorstream << "generateImage(): Failed to load \""
+						<< filename << "\".";
+			}
+		}
+		/*
+			[colorize:color
+			Overlays image with given color
+			color = color as ColorString
+		*/
+		else if (part_of_name.substr(0,10) == "[colorize:") {
+			Strfnd sf(part_of_name);
+			sf.next(":");
+			std::string color_str = sf.next(":");
+			std::string ratio_str = sf.next(":");
+
+			if (baseimg == NULL) {
+				errorstream << "generateImagePart(): baseimg != NULL "
+						<< "for part_of_name=\"" << part_of_name
+						<< "\", cancelling." << std::endl;
+				return false;
+			}
+
+			video::SColor color;
+			int ratio = -1;
+
+			if (!parseColorString(color_str, color, false))
+				return false;
+
+			if (is_number(ratio_str))
+				ratio = mystoi(ratio_str, 0, 255);
+
+			core::dimension2d<u32> dim = baseimg->getDimension();
+			video::IImage *img = driver->createImage(video::ECF_A8R8G8B8, dim);
+
+			if (!img) {
+				errorstream << "generateImagePart(): Could not create image "
+						<< "for part_of_name=\"" << part_of_name
+						<< "\", cancelling." << std::endl;
+				return false;
+			}
+
+			img->fill(video::SColor(color));
+			// Overlay the colored image
+			blit_with_interpolate_overlay(img, baseimg, v2s32(0,0), v2s32(0,0), dim, ratio);
+			img->drop();
+		}
+		else
+		{
+			errorstream << "generateImagePart(): Invalid "
+					" modification: \"" << part_of_name << "\"" << std::endl;
+		}
+	}
+
+	return true;
+}
+
+/*
+	Draw an image on top of an another one, using the alpha channel of the
+	source image
+
+	This exists because IImage::copyToWithAlpha() doesn't seem to always
+	work.
+*/
+static void blit_with_alpha(video::IImage *src, video::IImage *dst,
+		v2s32 src_pos, v2s32 dst_pos, v2u32 size)
+{
+	for (u32 y0=0; y0<size.Y; y0++)
+	for (u32 x0=0; x0<size.X; x0++)
+	{
+		s32 src_x = src_pos.X + x0;
+		s32 src_y = src_pos.Y + y0;
+		s32 dst_x = dst_pos.X + x0;
+		s32 dst_y = dst_pos.Y + y0;
+		video::SColor src_c = src->getPixel(src_x, src_y);
+		video::SColor dst_c = dst->getPixel(dst_x, dst_y);
+		dst_c = src_c.getInterpolated(dst_c, (float)src_c.getAlpha()/255.0f);
+		dst->setPixel(dst_x, dst_y, dst_c);
+	}
+}
+
+/*
+	Draw an image on top of an another one, using the alpha channel of the
+	source image; only modify fully opaque pixels in destinaion
+*/
+static void blit_with_alpha_overlay(video::IImage *src, video::IImage *dst,
+		v2s32 src_pos, v2s32 dst_pos, v2u32 size)
+{
+	for (u32 y0=0; y0<size.Y; y0++)
+	for (u32 x0=0; x0<size.X; x0++)
+	{
+		s32 src_x = src_pos.X + x0;
+		s32 src_y = src_pos.Y + y0;
+		s32 dst_x = dst_pos.X + x0;
+		s32 dst_y = dst_pos.Y + y0;
+		video::SColor src_c = src->getPixel(src_x, src_y);
+		video::SColor dst_c = dst->getPixel(dst_x, dst_y);
+		if (dst_c.getAlpha() == 255 && src_c.getAlpha() != 0)
+		{
+			dst_c = src_c.getInterpolated(dst_c, (float)src_c.getAlpha()/255.0f);
+			dst->setPixel(dst_x, dst_y, dst_c);
+		}
+	}
+}
+
+/*
+	Draw an image on top of an another one, using the specified ratio
+	modify all partially-opaque pixels in the destination.
+*/
+static void blit_with_interpolate_overlay(video::IImage *src, video::IImage *dst,
+		v2s32 src_pos, v2s32 dst_pos, v2u32 size, int ratio)
+{
+	for (u32 y0 = 0; y0 < size.Y; y0++)
+	for (u32 x0 = 0; x0 < size.X; x0++)
+	{
+		s32 src_x = src_pos.X + x0;
+		s32 src_y = src_pos.Y + y0;
+		s32 dst_x = dst_pos.X + x0;
+		s32 dst_y = dst_pos.Y + y0;
+		video::SColor src_c = src->getPixel(src_x, src_y);
+		video::SColor dst_c = dst->getPixel(dst_x, dst_y);
+		if (dst_c.getAlpha() > 0 && src_c.getAlpha() != 0)
+		{
+			if (ratio == -1)
+				dst_c = src_c.getInterpolated(dst_c, (float)src_c.getAlpha()/255.0f);
+			else
+				dst_c = src_c.getInterpolated(dst_c, (float)ratio/255.0f);
+			dst->setPixel(dst_x, dst_y, dst_c);
+		}
+	}
+}
+
+/*
+	Apply mask to destination
+*/
+static void apply_mask(video::IImage *mask, video::IImage *dst,
+		v2s32 mask_pos, v2s32 dst_pos, v2u32 size)
+{
+	for (u32 y0 = 0; y0 < size.Y; y0++) {
+		for (u32 x0 = 0; x0 < size.X; x0++) {
+			s32 mask_x = x0 + mask_pos.X;
+			s32 mask_y = y0 + mask_pos.Y;
+			s32 dst_x = x0 + dst_pos.X;
+			s32 dst_y = y0 + dst_pos.Y;
+			video::SColor mask_c = mask->getPixel(mask_x, mask_y);
+			video::SColor dst_c = dst->getPixel(dst_x, dst_y);
+			dst_c.color &= mask_c.color;
+			dst->setPixel(dst_x, dst_y, dst_c);
+		}
+	}
+}
+
+static void draw_crack(video::IImage *crack, video::IImage *dst,
+		bool use_overlay, s32 frame_count, s32 progression,
+		video::IVideoDriver *driver)
+{
+	// Dimension of destination image
+	core::dimension2d<u32> dim_dst = dst->getDimension();
+	// Dimension of original image
+	core::dimension2d<u32> dim_crack = crack->getDimension();
+	// Count of crack stages
+	s32 crack_count = dim_crack.Height / dim_crack.Width;
+	// Limit frame_count
+	if (frame_count > (s32) dim_dst.Height)
+		frame_count = dim_dst.Height;
+	if (frame_count < 1)
+		frame_count = 1;
+	// Limit progression
+	if (progression > crack_count-1)
+		progression = crack_count-1;
+	// Dimension of a single crack stage
+	core::dimension2d<u32> dim_crack_cropped(
+		dim_crack.Width,
+		dim_crack.Width
+	);
+	// Dimension of the scaled crack stage,
+	// which is the same as the dimension of a single destination frame
+	core::dimension2d<u32> dim_crack_scaled(
+		dim_dst.Width,
+		dim_dst.Height / frame_count
+	);
+	// Create cropped and scaled crack images
+	video::IImage *crack_cropped = driver->createImage(
+			video::ECF_A8R8G8B8, dim_crack_cropped);
+	video::IImage *crack_scaled = driver->createImage(
+			video::ECF_A8R8G8B8, dim_crack_scaled);
+
+	if (crack_cropped && crack_scaled)
+	{
+		// Crop crack image
+		v2s32 pos_crack(0, progression*dim_crack.Width);
+		crack->copyTo(crack_cropped,
+				v2s32(0,0),
+				core::rect<s32>(pos_crack, dim_crack_cropped));
+		// Scale crack image by copying
+		crack_cropped->copyToScaling(crack_scaled);
+		// Copy or overlay crack image onto each frame
+		for (s32 i = 0; i < frame_count; ++i)
+		{
+			v2s32 dst_pos(0, dim_crack_scaled.Height * i);
+			if (use_overlay)
+			{
+				blit_with_alpha_overlay(crack_scaled, dst,
+						v2s32(0,0), dst_pos,
+						dim_crack_scaled);
+			}
+			else
+			{
+				blit_with_alpha(crack_scaled, dst,
+						v2s32(0,0), dst_pos,
+						dim_crack_scaled);
+			}
+		}
+	}
+
+	if (crack_scaled)
+		crack_scaled->drop();
+
+	if (crack_cropped)
+		crack_cropped->drop();
+}
+
+void brighten(video::IImage *image)
+{
+	if (image == NULL)
+		return;
+
+	core::dimension2d<u32> dim = image->getDimension();
+
+	for (u32 y=0; y<dim.Height; y++)
+	for (u32 x=0; x<dim.Width; x++)
+	{
+		video::SColor c = image->getPixel(x,y);
+		c.setRed(0.5 * 255 + 0.5 * (float)c.getRed());
+		c.setGreen(0.5 * 255 + 0.5 * (float)c.getGreen());
+		c.setBlue(0.5 * 255 + 0.5 * (float)c.getBlue());
+		image->setPixel(x,y,c);
+	}
+}
+
+u32 parseImageTransform(const std::string& s)
+{
+	int total_transform = 0;
+
+	std::string transform_names[8];
+	transform_names[0] = "i";
+	transform_names[1] = "r90";
+	transform_names[2] = "r180";
+	transform_names[3] = "r270";
+	transform_names[4] = "fx";
+	transform_names[6] = "fy";
+
+	std::size_t pos = 0;
+	while(pos < s.size())
+	{
+		int transform = -1;
+		for (int i = 0; i <= 7; ++i)
+		{
+			const std::string &name_i = transform_names[i];
+
+			if (s[pos] == ('0' + i))
+			{
+				transform = i;
+				pos++;
+				break;
+			}
+			else if (!(name_i.empty()) &&
+				lowercase(s.substr(pos, name_i.size())) == name_i)
+			{
+				transform = i;
+				pos += name_i.size();
+				break;
+			}
+		}
+		if (transform < 0)
+			break;
+
+		// Multiply total_transform and transform in the group D4
+		int new_total = 0;
+		if (transform < 4)
+			new_total = (transform + total_transform) % 4;
+		else
+			new_total = (transform - total_transform + 8) % 4;
+		if ((transform >= 4) ^ (total_transform >= 4))
+			new_total += 4;
+
+		total_transform = new_total;
+	}
+	return total_transform;
+}
+
+core::dimension2d<u32> imageTransformDimension(u32 transform, core::dimension2d<u32> dim)
+{
+	if (transform % 2 == 0)
+		return dim;
+	else
+		return core::dimension2d<u32>(dim.Height, dim.Width);
+}
+
+void imageTransform(u32 transform, video::IImage *src, video::IImage *dst)
+{
+	if (src == NULL || dst == NULL)
+		return;
+
+	core::dimension2d<u32> srcdim = src->getDimension();
+	core::dimension2d<u32> dstdim = dst->getDimension();
+
+	assert(dstdim == imageTransformDimension(transform, srcdim));
+	assert(transform <= 7);
+
+	/*
+		Compute the transformation from source coordinates (sx,sy)
+		to destination coordinates (dx,dy).
+	*/
+	int sxn = 0;
+	int syn = 2;
+	if (transform == 0)         // identity
+		sxn = 0, syn = 2;  //   sx = dx, sy = dy
+	else if (transform == 1)    // rotate by 90 degrees ccw
+		sxn = 3, syn = 0;  //   sx = (H-1) - dy, sy = dx
+	else if (transform == 2)    // rotate by 180 degrees
+		sxn = 1, syn = 3;  //   sx = (W-1) - dx, sy = (H-1) - dy
+	else if (transform == 3)    // rotate by 270 degrees ccw
+		sxn = 2, syn = 1;  //   sx = dy, sy = (W-1) - dx
+	else if (transform == 4)    // flip x
+		sxn = 1, syn = 2;  //   sx = (W-1) - dx, sy = dy
+	else if (transform == 5)    // flip x then rotate by 90 degrees ccw
+		sxn = 2, syn = 0;  //   sx = dy, sy = dx
+	else if (transform == 6)    // flip y
+		sxn = 0, syn = 3;  //   sx = dx, sy = (H-1) - dy
+	else if (transform == 7)    // flip y then rotate by 90 degrees ccw
+		sxn = 3, syn = 1;  //   sx = (H-1) - dy, sy = (W-1) - dx
+
+	for (u32 dy=0; dy<dstdim.Height; dy++)
+	for (u32 dx=0; dx<dstdim.Width; dx++)
+	{
+		u32 entries[4] = {dx, dstdim.Width-1-dx, dy, dstdim.Height-1-dy};
+		u32 sx = entries[sxn];
+		u32 sy = entries[syn];
+		video::SColor c = src->getPixel(sx,sy);
+		dst->setPixel(dx,dy,c);
+	}
+}
+
+video::ITexture* TextureSource::getNormalTexture(const std::string &name)
+{
+	u32 id;
+	if (isKnownSourceImage("override_normal.png"))
+		return getTexture("override_normal.png", &id);
+	std::string fname_base = name;
+	std::string normal_ext = "_normal.png";
+	size_t pos = fname_base.find(".");
+	std::string fname_normal = fname_base.substr(0, pos) + normal_ext;
+	if (isKnownSourceImage(fname_normal)) {
+		// look for image extension and replace it
+		size_t i = 0;
+		while ((i = fname_base.find(".", i)) != std::string::npos) {
+			fname_base.replace(i, 4, normal_ext);
+			i += normal_ext.length();
+		}
+		return getTexture(fname_base, &id);
+		}
+	return NULL;
+}