X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Ftile.cpp;h=23fa1129da78bca05411aadacdacca0f2f99816e;hb=2915bd5518150955ed1581110527f4bb4adadfe8;hp=f31f830762fb8096f3c0fcc3b061345343a02fd7;hpb=1704badc306fc8c7c6609aff9f809aee3ac00d3a;p=dragonfireclient.git

diff --git a/src/tile.cpp b/src/tile.cpp
index f31f83076..23fa1129d 100644
--- a/src/tile.cpp
+++ b/src/tile.cpp
@@ -1,6 +1,6 @@
 /*
 Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2011 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 General Public License as published by
@@ -19,6 +19,127 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "tile.h"
 #include "debug.h"
+#include "main.h" // for g_settings
+#include "filesys.h"
+#include "utility.h"
+
+/*
+	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 "".
+*/
+static 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
+	};
+
+	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 + '/' + filename;
+		// Check all filename extensions. Returns "" if not found.
+		fullpath = getImagePath(testpath);
+	}
+	
+	/*
+		Check from default data directory
+	*/
+	if(fullpath == "")
+	{
+		std::string testpath = porting::getDataPath(filename.c_str());
+		// 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;
+}
+
+/*
+	TextureSource
+*/
 
 TextureSource::TextureSource(IrrlichtDevice *device):
 		m_device(device),
@@ -36,7 +157,10 @@ TextureSource::TextureSource(IrrlichtDevice *device):
 	m_name_to_id[""] = 0;
 
 	// Build main texture atlas
-	buildMainAtlas();
+	if(g_settings.getBool("enable_texture_atlas"))
+		buildMainAtlas();
+	else
+		dstream<<"INFO: Not building texture atlas."<<std::endl;
 }
 
 TextureSource::~TextureSource()
@@ -136,7 +260,7 @@ void make_progressbar(float value, video::IImage *image);
 	if baseimg is NULL, it is created. Otherwise stuff is made on it.
 */
 bool generate_image(std::string part_of_name, video::IImage *& baseimg,
-		video::IVideoDriver* driver);
+		IrrlichtDevice *device);
 
 /*
 	Generates an image from a full string like
@@ -145,7 +269,7 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 	This is used by buildMainAtlas().
 */
 video::IImage* generate_image_from_scratch(std::string name,
-		video::IVideoDriver* driver);
+		IrrlichtDevice *device);
 
 /*
 	This method generates all the textures
@@ -247,23 +371,32 @@ u32 TextureSource::getTextureIdDirect(const std::string &name)
 		SourceAtlasPointer ap = m_atlaspointer_cache[base_image_id];
 
 		video::IImage *image = ap.atlas_img;
+		
+		if(image == NULL)
+		{
+			dstream<<"WARNING: getTextureIdDirect(): NULL image in "
+					<<"cache: \""<<base_image_name<<"\""
+					<<std::endl;
+		}
+		else
+		{
+			core::dimension2d<u32> dim = ap.intsize;
 
-		core::dimension2d<u32> dim = ap.intsize;
-
-		baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
+			baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
 
-		core::position2d<s32> pos_to(0,0);
-		core::position2d<s32> pos_from = ap.intpos;
-		
-		image->copyTo(
-				baseimg, // target
-				v2s32(0,0), // position in target
-				core::rect<s32>(pos_from, dim) // from
-		);
-
-		dstream<<"INFO: getTextureIdDirect(): Loaded \""
-				<<base_image_name<<"\" from image cache"
-				<<std::endl;
+			core::position2d<s32> pos_to(0,0);
+			core::position2d<s32> pos_from = ap.intpos;
+			
+			image->copyTo(
+					baseimg, // target
+					v2s32(0,0), // position in target
+					core::rect<s32>(pos_from, dim) // from
+			);
+
+			dstream<<"INFO: getTextureIdDirect(): Loaded \""
+					<<base_image_name<<"\" from image cache"
+					<<std::endl;
+		}
 	}
 	
 	/*
@@ -273,33 +406,30 @@ u32 TextureSource::getTextureIdDirect(const std::string &name)
 
 	std::string last_part_of_name = name.substr(last_separator_position+1);
 	dstream<<"last_part_of_name="<<last_part_of_name<<std::endl;
-	
+
 	// Generate image according to part of name
-	if(generate_image(last_part_of_name, baseimg, driver) == false)
+	if(generate_image(last_part_of_name, baseimg, m_device) == false)
 	{
 		dstream<<"INFO: getTextureIdDirect(): "
 				"failed to generate \""<<last_part_of_name<<"\""
 				<<std::endl;
-		return 0;
 	}
 
-	// If no resulting image, return NULL
+	// If no resulting image, print a warning
 	if(baseimg == NULL)
 	{
 		dstream<<"WARNING: getTextureIdDirect(): baseimg is NULL (attempted to"
 				" create texture \""<<name<<"\""<<std::endl;
-		return 0;
 	}
-
-	// Create texture from resulting image
-	t = driver->addTexture(name.c_str(), baseimg);
 	
-	// If no texture
-	if(t == NULL)
-		return 0;
-
+	if(baseimg != NULL)
+	{
+		// Create texture from resulting image
+		t = driver->addTexture(name.c_str(), baseimg);
+	}
+	
 	/*
-		Add texture to caches
+		Add texture to caches (add NULL textures too)
 	*/
 
 	JMutexAutoLock lock(m_atlaspointer_cache_mutex);
@@ -310,7 +440,10 @@ u32 TextureSource::getTextureIdDirect(const std::string &name)
 	ap.pos = v2f(0,0);
 	ap.size = v2f(1,1);
 	ap.tiled = 0;
-	SourceAtlasPointer nap(name, ap, baseimg, v2s32(0,0), baseimg->getDimension());
+	core::dimension2d<u32> baseimg_dim(0,0);
+	if(baseimg)
+		baseimg_dim = baseimg->getDimension();
+	SourceAtlasPointer nap(name, ap, baseimg, v2s32(0,0), baseimg_dim);
 	m_atlaspointer_cache.push_back(nap);
 	m_name_to_id.insert(name, id);
 
@@ -361,6 +494,7 @@ void TextureSource::buildMainAtlas()
 	core::dimension2d<u32> atlas_dim(1024,1024);
 	video::IImage *atlas_img =
 			driver->createImage(video::ECF_A8R8G8B8, atlas_dim);
+	assert(atlas_img);
 
 	/*
 		A list of stuff to add. This should contain as much of the
@@ -373,12 +507,16 @@ void TextureSource::buildMainAtlas()
 	sourcelist.push_back("mud.png");
 	sourcelist.push_back("sand.png");
 	sourcelist.push_back("grass.png");
-	sourcelist.push_back("mud.png");
+	sourcelist.push_back("grass_footsteps.png");
 	sourcelist.push_back("tree.png");
 	sourcelist.push_back("tree_top.png");
 	sourcelist.push_back("water.png");
 	sourcelist.push_back("leaves.png");
+	sourcelist.push_back("glass.png");
 	sourcelist.push_back("mud.png^grass_side.png");
+	sourcelist.push_back("cobble.png");
+	sourcelist.push_back("mossycobble.png");
+	sourcelist.push_back("gravel.png");
 	
 	sourcelist.push_back("stone.png^mineral_coal.png");
 	sourcelist.push_back("stone.png^mineral_iron.png");
@@ -387,16 +525,22 @@ void TextureSource::buildMainAtlas()
 	sourcelist.push_back("sand.png^mineral_coal.png");
 	sourcelist.push_back("sand.png^mineral_iron.png");
 	
+	// Padding to disallow texture bleeding
+	s32 padding = 16;
+
 	/*
 		First pass: generate almost everything
 	*/
 	core::position2d<s32> pos_in_atlas(0,0);
+	
+	pos_in_atlas.Y += padding;
+
 	for(u32 i=0; i<sourcelist.size(); i++)
 	{
 		std::string name = sourcelist[i];
 
 		/*video::IImage *img = driver->createImageFromFile(
-				porting::getDataPath(name.c_str()).c_str());
+				getTexturePath(name.c_str()).c_str());
 		if(img == NULL)
 			continue;
 		
@@ -408,8 +552,33 @@ void TextureSource::buildMainAtlas()
 		img->drop();*/
 		
 		// Generate image by name
-		video::IImage *img2 = generate_image_from_scratch(name, driver);
+		video::IImage *img2 = generate_image_from_scratch(name, m_device);
+		if(img2 == NULL)
+		{
+			dstream<<"WARNING: TextureSource::buildMainAtlas(): Couldn't generate texture atlas: Couldn't generate image \""<<name<<"\""<<std::endl;
+			continue;
+		}
+
 		core::dimension2d<u32> dim = img2->getDimension();
+
+		// Don't add to atlas if image is large
+		core::dimension2d<u32> max_size_in_atlas(32,32);
+		if(dim.Width > max_size_in_atlas.Width
+		|| dim.Height > max_size_in_atlas.Height)
+		{
+			dstream<<"INFO: TextureSource::buildMainAtlas(): Not adding "
+					<<"\""<<name<<"\" because image is large"<<std::endl;
+			continue;
+		}
+
+		// Stop making atlas if atlas is full
+		if(pos_in_atlas.Y + dim.Height > atlas_dim.Height)
+		{
+			dstream<<"WARNING: TextureSource::buildMainAtlas(): "
+					<<"Atlas is full, not adding more textures."
+					<<std::endl;
+			break;
+		}
 		
 		// Tile it a few times in the X direction
 		u16 xwise_tiling = 16;
@@ -423,6 +592,28 @@ void TextureSource::buildMainAtlas()
 					NULL);
 		}
 
+		// Copy the borders a few times to disallow texture bleeding
+		for(u32 side=0; side<2; side++) // top and bottom
+		for(s32 y0=0; y0<padding; y0++)
+		for(s32 x0=0; x0<(s32)xwise_tiling*(s32)dim.Width; x0++)
+		{
+			s32 dst_y;
+			s32 src_y;
+			if(side==0)
+			{
+				dst_y = y0 + pos_in_atlas.Y + dim.Height;
+				src_y = pos_in_atlas.Y + dim.Height - 1;
+			}
+			else
+			{
+				dst_y = -y0 + pos_in_atlas.Y-1;
+				src_y = pos_in_atlas.Y;
+			}
+			s32 x = x0 + pos_in_atlas.X * dim.Width;
+			video::SColor c = atlas_img->getPixel(x, src_y);
+			atlas_img->setPixel(x,dst_y,c);
+		}
+
 		img2->drop();
 
 		/*
@@ -447,7 +638,7 @@ void TextureSource::buildMainAtlas()
 		m_name_to_id.insert(name, id);
 			
 		// Increment position
-		pos_in_atlas.Y += dim.Height;
+		pos_in_atlas.Y += dim.Height + padding * 2;
 	}
 
 	/*
@@ -462,23 +653,29 @@ void TextureSource::buildMainAtlas()
 	for(u32 i=0; i<sourcelist.size(); i++)
 	{
 		std::string name = sourcelist[i];
+		if(m_name_to_id.find(name) == NULL)
+			continue;
 		u32 id = m_name_to_id[name];
+		//dstream<<"id of name "<<name<<" is "<<id<<std::endl;
 		m_atlaspointer_cache[id].a.atlas = t;
 	}
 
 	/*
 		Write image to file so that it can be inspected
 	*/
-	driver->writeImageToFile(atlas_img, 
-			porting::getDataPath("main_atlas.png").c_str());
+	/*driver->writeImageToFile(atlas_img, 
+			getTexturePath("main_atlas.png").c_str());*/
 }
 
 video::IImage* generate_image_from_scratch(std::string name,
-		video::IVideoDriver* driver)
+		IrrlichtDevice *device)
 {
 	dstream<<"INFO: generate_image_from_scratch(): "
 			"name="<<name<<std::endl;
 	
+	video::IVideoDriver* driver = device->getVideoDriver();
+	assert(driver);
+
 	/*
 		Get the base image
 	*/
@@ -513,7 +710,7 @@ video::IImage* generate_image_from_scratch(std::string name,
 		base_image_name = name.substr(0, last_separator_position);
 		dstream<<"INFO: generate_image_from_scratch(): Calling itself recursively"
 				" to get base image, name="<<base_image_name<<std::endl;
-		baseimg = generate_image_from_scratch(base_image_name, driver);
+		baseimg = generate_image_from_scratch(base_image_name, device);
 	}
 	
 	/*
@@ -525,7 +722,7 @@ video::IImage* generate_image_from_scratch(std::string name,
 	dstream<<"last_part_of_name="<<last_part_of_name<<std::endl;
 	
 	// Generate image according to part of name
-	if(generate_image(last_part_of_name, baseimg, driver) == false)
+	if(generate_image(last_part_of_name, baseimg, device) == false)
 	{
 		dstream<<"INFO: generate_image_from_scratch(): "
 				"failed to generate \""<<last_part_of_name<<"\""
@@ -537,13 +734,16 @@ video::IImage* generate_image_from_scratch(std::string name,
 }
 
 bool generate_image(std::string part_of_name, video::IImage *& baseimg,
-		video::IVideoDriver* driver)
+		IrrlichtDevice *device)
 {
+	video::IVideoDriver* driver = device->getVideoDriver();
+	assert(driver);
+
 	// Stuff starting with [ are special commands
 	if(part_of_name[0] != '[')
 	{
 		// A normal texture; load it from a file
-		std::string path = porting::getDataPath(part_of_name.c_str());
+		std::string path = getTexturePath(part_of_name.c_str());
 		dstream<<"INFO: getTextureIdDirect(): Loading path \""<<path
 				<<"\""<<std::endl;
 		
@@ -554,7 +754,29 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 			dstream<<"WARNING: Could not load image \""<<part_of_name
 					<<"\" from path \""<<path<<"\""
 					<<" while building texture"<<std::endl;
-			return false;
+
+			//return false;
+
+			dstream<<"WARNING: Creating a dummy"<<" image 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.
@@ -598,8 +820,23 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 		dstream<<"INFO: getTextureIdDirect(): generating special "
 				<<"modification \""<<part_of_name<<"\""
 				<<std::endl;
+		
+		/*
+			This is the simplest of all; it just adds stuff to the
+			name so that a separate texture is created.
 
-		if(part_of_name.substr(0,6) == "[crack")
+			It is used to make textures for stuff that doesn't want
+			to implement getting the texture from a bigger texture
+			atlas.
+		*/
+		if(part_of_name == "[forcesingle")
+		{
+		}
+		/*
+			[crackN
+			Adds a cracking texture
+		*/
+		else if(part_of_name.substr(0,6) == "[crack")
 		{
 			if(baseimg == NULL)
 			{
@@ -608,44 +845,91 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 						<<", cancelling."<<std::endl;
 				return false;
 			}
-
+			
+			// Crack image number
 			u16 progression = stoi(part_of_name.substr(6));
+
 			// Size of the base image
 			core::dimension2d<u32> dim_base = baseimg->getDimension();
-			// Crack will be drawn at this size
-			u32 cracksize = 16;
-			// Size of the crack image
-			core::dimension2d<u32> dim_crack(cracksize,cracksize);
-			// Position to copy the crack from in the crack image
-			core::position2d<s32> pos_other(0, 16 * progression);
-
-			video::IImage *crackimage = driver->createImageFromFile(
-					porting::getDataPath("crack.png").c_str());
+			
+			/*
+				Load crack image.
+
+				It is an image with a number of cracking stages
+				horizontally tiled.
+			*/
+			video::IImage *img_crack = driver->createImageFromFile(
+					getTexturePath("crack.png").c_str());
 		
-			if(crackimage)
+			if(img_crack)
 			{
-				/*crackimage->copyToWithAlpha(baseimg, v2s32(0,0),
-						core::rect<s32>(pos_other, dim_base),
-						video::SColor(255,255,255,255),
-						NULL);*/
-
-				for(u32 y0=0; y0<dim_base.Height/dim_crack.Height; y0++)
-				for(u32 x0=0; x0<dim_base.Width/dim_crack.Width; x0++)
+				// Dimension of original image
+				core::dimension2d<u32> dim_crack
+						= img_crack->getDimension();
+				// Count of crack stages
+				u32 crack_count = dim_crack.Height / dim_crack.Width;
+				// Limit progression
+				if(progression > crack_count-1)
+					progression = crack_count-1;
+				// Dimension of a single scaled crack stage
+				core::dimension2d<u32> dim_crack_scaled_single(
+					dim_base.Width,
+					dim_base.Height
+				);
+				// Dimension of scaled size
+				core::dimension2d<u32> dim_crack_scaled(
+					dim_crack_scaled_single.Width,
+					dim_crack_scaled_single.Height * crack_count
+				);
+				// Create scaled crack image
+				video::IImage *img_crack_scaled = driver->createImage(
+						video::ECF_A8R8G8B8, dim_crack_scaled);
+				if(img_crack_scaled)
 				{
-					// Position to copy the crack to in the base image
-					core::position2d<s32> pos_base(x0*cracksize, y0*cracksize);
-					crackimage->copyToWithAlpha(baseimg, pos_base,
-							core::rect<s32>(pos_other, dim_crack),
-							video::SColor(255,255,255,255),
-							NULL);
+					// Scale crack image by copying
+					img_crack->copyToScaling(img_crack_scaled);
+					
+					// Position to copy the crack from
+					core::position2d<s32> pos_crack_scaled(
+						0,
+						dim_crack_scaled_single.Height * progression
+					);
+					
+					// This tiling does nothing currently but is useful
+					for(u32 y0=0; y0<dim_base.Height
+							/ dim_crack_scaled_single.Height; y0++)
+					for(u32 x0=0; x0<dim_base.Width
+							/ dim_crack_scaled_single.Width; x0++)
+					{
+						// Position to copy the crack to in the base image
+						core::position2d<s32> pos_base(
+							x0*dim_crack_scaled_single.Width,
+							y0*dim_crack_scaled_single.Height
+						);
+						// Rectangle to copy the crack from on the scaled image
+						core::rect<s32> rect_crack_scaled(
+							pos_crack_scaled,
+							dim_crack_scaled_single
+						);
+						// Copy it
+						img_crack_scaled->copyToWithAlpha(baseimg, pos_base,
+								rect_crack_scaled,
+								video::SColor(255,255,255,255),
+								NULL);
+					}
+
+					img_crack_scaled->drop();
 				}
-
-				crackimage->drop();
+				
+				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")
 		{
-			// "[combine:16x128:0,0=stone.png:0,16=grass.png"
 			Strfnd sf(part_of_name);
 			sf.next(":");
 			u32 w0 = stoi(sf.next("x"));
@@ -662,7 +946,7 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 						<<"\" to combined ("<<x<<","<<y<<")"
 						<<std::endl;
 				video::IImage *img = driver->createImageFromFile(
-						porting::getDataPath(filename.c_str()).c_str());
+						getTexturePath(filename.c_str()).c_str());
 				if(img)
 				{
 					core::dimension2d<u32> dim = img->getDimension();
@@ -685,6 +969,10 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 				}
 			}
 		}
+		/*
+			[progressbarN
+			Adds a progress bar, 0.0 <= N <= 1.0
+		*/
 		else if(part_of_name.substr(0,12) == "[progressbar")
 		{
 			if(baseimg == NULL)
@@ -698,8 +986,13 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 			float value = stof(part_of_name.substr(12));
 			make_progressbar(value, baseimg);
 		}
-		// "[noalpha:filename.png"
-		// Use an image without it's alpha channel
+		/*
+			"[noalpha:filename.png"
+			Use an image without it's alpha channel.
+			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)
@@ -712,7 +1005,7 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 
 			std::string filename = part_of_name.substr(9);
 
-			std::string path = porting::getDataPath(filename.c_str());
+			std::string path = getTexturePath(filename.c_str());
 
 			dstream<<"INFO: getTextureIdDirect(): Loading path \""<<path
 					<<"\""<<std::endl;
@@ -743,6 +1036,145 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 				image->drop();
 			}
 		}
+		/*
+			[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)
+			{
+				dstream<<"WARNING: getTextureIdDirect(): baseimg!=NULL "
+						<<"for part_of_name="<<part_of_name
+						<<", cancelling."<<std::endl;
+				return false;
+			}
+
+			str_replace_char(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("{");
+
+#if 1
+			//TODO
+
+			if(driver->queryFeature(video::EVDF_RENDER_TO_TARGET) == false)
+			{
+				dstream<<"WARNING: getTextureIdDirect(): EVDF_RENDER_TO_TARGET"
+						" not supported. Creating fallback image"<<std::endl;
+				baseimg = generate_image_from_scratch(
+						imagename_top, device);
+				return true;
+			}
+			
+			u32 w0 = 64;
+			u32 h0 = 64;
+			dstream<<"INFO: inventorycube w="<<w0<<" h="<<h0<<std::endl;
+			core::dimension2d<u32> dim(w0,h0);
+			
+			// Generate images for the faces of the cube
+			video::IImage *img_top = generate_image_from_scratch(
+					imagename_top, device);
+			video::IImage *img_left = generate_image_from_scratch(
+					imagename_left, device);
+			video::IImage *img_right = generate_image_from_scratch(
+					imagename_right, device);
+			assert(img_top && img_left && img_right);
+
+			// TODO: Create textures from images
+			video::ITexture *texture_top = driver->addTexture(
+					(imagename_top + "__temp__").c_str(), img_top);
+			assert(texture_top);
+			
+			// Drop images
+			img_top->drop();
+			img_left->drop();
+			img_right->drop();
+			
+			// Create render target texture
+			video::ITexture *rtt = NULL;
+			std::string rtt_name = part_of_name + "_RTT";
+			rtt = driver->addRenderTargetTexture(dim, rtt_name.c_str(),
+					video::ECF_A8R8G8B8);
+			assert(rtt);
+			
+			// Set render target
+			driver->setRenderTarget(rtt, true, true,
+					video::SColor(0,0,0,0));
+			
+			// Get a scene manager
+			scene::ISceneManager *smgr_main = device->getSceneManager();
+			assert(smgr_main);
+			scene::ISceneManager *smgr = smgr_main->createNewSceneManager();
+			assert(smgr);
+			
+			/*
+				Create scene:
+				- An unit cube is centered at 0,0,0
+				- Camera looks at cube from Y+, Z- towards Y-, Z+
+				NOTE: Cube has to be changed to something else because
+				the textures cannot be set individually (or can they?)
+			*/
+
+			scene::ISceneNode* cube = smgr->addCubeSceneNode(1.0, NULL, -1,
+					v3f(0,0,0), v3f(0, 45, 0));
+			// Set texture of cube
+			cube->setMaterialTexture(0, texture_top);
+			//cube->setMaterialFlag(video::EMF_LIGHTING, false);
+			cube->setMaterialFlag(video::EMF_ANTI_ALIASING, false);
+			cube->setMaterialFlag(video::EMF_BILINEAR_FILTER, false);
+
+			scene::ICameraSceneNode* camera = smgr->addCameraSceneNode(0,
+					v3f(0, 1.0, -1.5), v3f(0, 0, 0));
+			// Set orthogonal projection
+			core::CMatrix4<f32> pm;
+			pm.buildProjectionMatrixOrthoLH(1.65, 1.65, 0, 100);
+			camera->setProjectionMatrix(pm, true);
+
+			/*scene::ILightSceneNode *light =*/ smgr->addLightSceneNode(0,
+					v3f(-50, 100, 0), video::SColorf(0.5,0.5,0.5), 1000);
+
+			smgr->setAmbientLight(video::SColorf(0.2,0.2,0.2));
+
+			// Render scene
+			driver->beginScene(true, true, video::SColor(0,0,0,0));
+			smgr->drawAll();
+			driver->endScene();
+			
+			// NOTE: The scene nodes should not be dropped, otherwise
+			//       smgr->drop() segfaults
+			/*cube->drop();
+			camera->drop();
+			light->drop();*/
+			// Drop scene manager
+			smgr->drop();
+			
+			// Unset render target
+			driver->setRenderTarget(0, true, true, 0);
+
+			//TODO: Free textures of images
+			driver->removeTexture(texture_top);
+			
+			// Create image of render target
+			video::IImage *image = driver->createImage(rtt, v2s32(0,0), dim);
+
+			assert(image);
+			
+			baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
+
+			if(image)
+			{
+				image->copyTo(baseimg);
+				image->drop();
+			}
+#endif
+		}
 		else
 		{
 			dstream<<"WARNING: getTextureIdDirect(): Invalid "
@@ -760,9 +1192,9 @@ void make_progressbar(float value, video::IImage *image)
 	
 	core::dimension2d<u32> size = image->getDimension();
 
-	u32 barheight = 1;
-	u32 barpad_x = 1;
-	u32 barpad_y = 1;
+	u32 barheight = size.Height/16;
+	u32 barpad_x = size.Width/16;
+	u32 barpad_y = size.Height/16;
 	u32 barwidth = size.Width - barpad_x*2;
 	v2u32 barpos(barpad_x, size.Height - barheight - barpad_y);