#include "main.h" // for g_settings
#include "filesys.h"
#include "utility.h"
+#include "settings.h"
+#include <ICameraSceneNode.h>
+#include "log.h"
+#include "mapnode.h" // For texture atlas making
+#include "mineral.h" // For texture atlas making
+#include "nodedef.h" // For texture atlas making
+#include "gamedef.h"
/*
A cache from texture name to texture path
/*
Check from texture_path
*/
- std::string texture_path = g_settings.get("texture_path");
+ std::string texture_path = g_settings->get("texture_path");
if(texture_path != "")
{
- std::string testpath = texture_path + '/' + filename;
+ std::string testpath = texture_path + DIR_DELIM + filename;
// Check all filename extensions. Returns "" if not found.
fullpath = getImagePath(testpath);
}
*/
if(fullpath == "")
{
- std::string testpath = porting::getDataPath(filename.c_str());
+ std::string rel_path = std::string("textures")+DIR_DELIM+filename;
+ std::string testpath = porting::path_data + DIR_DELIM + rel_path;
// Check all filename extensions. Returns "" if not found.
fullpath = getImagePath(testpath);
}
TextureSource
*/
+class TextureSource : public IWritableTextureSource
+{
+public:
+ TextureSource(IrrlichtDevice *device);
+ ~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^mineral1" and is specified as a part of some atlas.
+ - Now MapBlock::getNodeTile() stumbles upon a node which uses
+ texture id 1, and finds out that NODEMOD_CRACK must be applied
+ with progression=0
+ - 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^mineral1^crack0")
+
+ */
+
+ /*
+ Gets a texture id from cache or
+ - if main thread, from getTextureIdDirect
+ - if other thread, adds to request queue and waits for main thread
+ */
+ u32 getTextureId(const std::string &name);
+
+ /*
+ Example names:
+ "stone.png"
+ "stone.png^crack2"
+ "stone.png^blit:mineral_coal.png"
+ "stone.png^blit:mineral_coal.png^crack1"
+
+ - If texture specified by name is found from cache, return the
+ cached id.
+ - Otherwise generate the texture, add to cache and return id.
+ Recursion is used to find out the largest found part of the
+ texture and continue based on it.
+
+ The id 0 points to a NULL texture. It is returned in case of error.
+ */
+ u32 getTextureIdDirect(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.
+ */
+ AtlasPointer getTexture(u32 id);
+
+ AtlasPointer getTexture(const std::string &name)
+ {
+ return getTexture(getTextureId(name));
+ }
+
+ // Gets a separate texture
+ video::ITexture* getTextureRaw(const std::string &name)
+ {
+ AtlasPointer ap = getTexture(name);
+ return ap.atlas;
+ }
+
+ /*
+ Update new texture pointer and texture coordinates to an
+ AtlasPointer based on it's texture id
+ */
+ void updateAP(AtlasPointer &ap);
+
+ /*
+ Build the main texture atlas which contains most of the
+ textures.
+
+ This is called by the constructor.
+ */
+ void buildMainAtlas(class IGameDef *gamedef);
+
+ /*
+ Processes queued texture requests from other threads.
+
+ Shall be called from the main thread.
+ */
+ void processQueue();
+
+private:
+
+ // The id of the thread that is allowed to use irrlicht directly
+ threadid_t m_main_thread;
+ // The irrlicht device
+ IrrlichtDevice *m_device;
+
+ // A texture id is index in this array.
+ // The first position contains a NULL texture.
+ core::array<SourceAtlasPointer> m_atlaspointer_cache;
+ // Maps a texture name to an index in the former.
+ core::map<std::string, u32> m_name_to_id;
+ // The two former containers are behind this mutex
+ JMutex m_atlaspointer_cache_mutex;
+
+ // Main texture atlas. This is filled at startup and is then not touched.
+ video::IImage *m_main_atlas_image;
+ video::ITexture *m_main_atlas_texture;
+
+ // Queued texture fetches (to be processed by the main thread)
+ RequestQueue<std::string, u32, u8, u8> m_get_texture_queue;
+};
+
+IWritableTextureSource* createTextureSource(IrrlichtDevice *device)
+{
+ return new TextureSource(device);
+}
+
TextureSource::TextureSource(IrrlichtDevice *device):
m_device(device),
m_main_atlas_image(NULL),
// Add a NULL AtlasPointer as the first index, named ""
m_atlaspointer_cache.push_back(SourceAtlasPointer(""));
m_name_to_id[""] = 0;
-
- // Build main texture atlas
- if(g_settings.getBool("enable_texture_atlas"))
- buildMainAtlas();
- else
- dstream<<"INFO: Not building texture atlas."<<std::endl;
}
TextureSource::~TextureSource()
GetRequest<std::string, u32, u8, u8>
request = m_get_texture_queue.pop();
- dstream<<"INFO: TextureSource::processQueue(): "
+ infostream<<"TextureSource::processQueue(): "
<<"got texture request with "
- <<"name="<<request.key
+ <<"name=\""<<request.key<<"\""
<<std::endl;
GetResult<std::string, u32, u8, u8>
u32 TextureSource::getTextureId(const std::string &name)
{
- //dstream<<"INFO: getTextureId(): name="<<name<<std::endl;
+ //infostream<<"getTextureId(): \""<<name<<"\""<<std::endl;
{
/*
}
else
{
- dstream<<"INFO: getTextureId(): Queued: name="<<name<<std::endl;
+ infostream<<"getTextureId(): Queued: name=\""<<name<<"\""<<std::endl;
// We're gonna ask the result to be put into here
ResultQueue<std::string, u32, u8, u8> result_queue;
// Throw a request in
m_get_texture_queue.add(name, 0, 0, &result_queue);
- dstream<<"INFO: Waiting for texture from main thread, name="
- <<name<<std::endl;
+ infostream<<"Waiting for texture from main thread, name=\""
+ <<name<<"\""<<std::endl;
try
{
}
catch(ItemNotFoundException &e)
{
- dstream<<"WARNING: Waiting for texture timed out."<<std::endl;
+ infostream<<"Waiting for texture timed out."<<std::endl;
return 0;
}
}
- dstream<<"WARNING: getTextureId(): Failed"<<std::endl;
+ infostream<<"getTextureId(): Failed"<<std::endl;
return 0;
}
*/
u32 TextureSource::getTextureIdDirect(const std::string &name)
{
- dstream<<"INFO: getTextureIdDirect(): name="<<name<<std::endl;
+ //infostream<<"getTextureIdDirect(): name=\""<<name<<"\""<<std::endl;
// Empty name means texture 0
if(name == "")
{
- dstream<<"INFO: getTextureIdDirect(): name is empty"<<std::endl;
+ infostream<<"getTextureIdDirect(): name is empty"<<std::endl;
return 0;
}
*/
if(get_current_thread_id() != m_main_thread)
{
- dstream<<"ERROR: TextureSource::getTextureIdDirect() "
+ errorstream<<"TextureSource::getTextureIdDirect() "
"called not from main thread"<<std::endl;
return 0;
}
n = m_name_to_id.find(name);
if(n != NULL)
{
- dstream<<"INFO: getTextureIdDirect(): name="<<name
- <<" found in cache"<<std::endl;
+ infostream<<"getTextureIdDirect(): \""<<name
+ <<"\" found in cache"<<std::endl;
return n->getValue();
}
}
- dstream<<"INFO: getTextureIdDirect(): name="<<name
- <<" NOT found in cache. Creating it."<<std::endl;
+ infostream<<"getTextureIdDirect(): \""<<name
+ <<"\" NOT found in cache. Creating it."<<std::endl;
/*
Get the base image
{
// Construct base name
base_image_name = name.substr(0, last_separator_position);
- dstream<<"INFO: getTextureIdDirect(): Calling itself recursively"
- " to get base image, name="<<base_image_name<<std::endl;
+ /*infostream<<"getTextureIdDirect(): Calling itself recursively"
+ " to get base image of \""<<name<<"\" = \""
+ <<base_image_name<<"\""<<std::endl;*/
base_image_id = getTextureIdDirect(base_image_name);
}
- dstream<<"base_image_id="<<base_image_id<<std::endl;
+ //infostream<<"base_image_id="<<base_image_id<<std::endl;
video::IVideoDriver* driver = m_device->getVideoDriver();
assert(driver);
if(image == NULL)
{
- dstream<<"WARNING: getTextureIdDirect(): NULL image in "
+ infostream<<"getTextureIdDirect(): NULL image in "
<<"cache: \""<<base_image_name<<"\""
<<std::endl;
}
core::rect<s32>(pos_from, dim) // from
);
- dstream<<"INFO: getTextureIdDirect(): Loaded \""
+ /*infostream<<"getTextureIdDirect(): Loaded \""
<<base_image_name<<"\" from image cache"
- <<std::endl;
+ <<std::endl;*/
}
}
*/
std::string last_part_of_name = name.substr(last_separator_position+1);
- dstream<<"last_part_of_name="<<last_part_of_name<<std::endl;
+ //infostream<<"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, m_device) == false)
{
- dstream<<"INFO: getTextureIdDirect(): "
+ infostream<<"getTextureIdDirect(): "
"failed to generate \""<<last_part_of_name<<"\""
<<std::endl;
}
// If no resulting image, print a warning
if(baseimg == NULL)
{
- dstream<<"WARNING: getTextureIdDirect(): baseimg is NULL (attempted to"
+ infostream<<"getTextureIdDirect(): baseimg is NULL (attempted to"
" create texture \""<<name<<"\""<<std::endl;
}
m_atlaspointer_cache.push_back(nap);
m_name_to_id.insert(name, id);
- dstream<<"INFO: getTextureIdDirect(): name="<<name
- <<": succesfully returning id="<<id<<std::endl;
+ /*infostream<<"getTextureIdDirect(): "
+ <<"Returning id="<<id<<" for name \""<<name<<"\""<<std::endl;*/
return id;
}
if(id >= m_atlaspointer_cache.size())
{
- dstream<<"WARNING: TextureSource::getTextureName(): id="<<id
+ infostream<<"TextureSource::getTextureName(): id="<<id
<<" >= m_atlaspointer_cache.size()="
<<m_atlaspointer_cache.size()<<std::endl;
return "";
return m_atlaspointer_cache[id].a;
}
-void TextureSource::buildMainAtlas()
+void TextureSource::updateAP(AtlasPointer &ap)
{
- dstream<<"TextureSource::buildMainAtlas()"<<std::endl;
+ AtlasPointer ap2 = getTexture(ap.id);
+ ap = ap2;
+}
+
+void TextureSource::buildMainAtlas(class IGameDef *gamedef)
+{
+ assert(gamedef->tsrc() == this);
+ INodeDefManager *ndef = gamedef->ndef();
+
+ infostream<<"TextureSource::buildMainAtlas()"<<std::endl;
//return; // Disable (for testing)
core::dimension2d<u32> atlas_dim(1024,1024);
video::IImage *atlas_img =
driver->createImage(video::ECF_A8R8G8B8, atlas_dim);
- assert(atlas_img);
+ //assert(atlas_img);
+ if(atlas_img == NULL)
+ {
+ errorstream<<"TextureSource::buildMainAtlas(): Failed to create atlas "
+ "image; not building texture atlas."<<std::endl;
+ return;
+ }
/*
- A list of stuff to add. This should contain as much of the
- stuff shown in game as possible, to minimize texture changes.
+ Grab list of stuff to include in the texture atlas from the
+ main content features
*/
- core::array<std::string> sourcelist;
-
- sourcelist.push_back("stone.png");
- sourcelist.push_back("mud.png");
- sourcelist.push_back("sand.png");
- sourcelist.push_back("grass.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("stone.png^mineral_coal.png");
- sourcelist.push_back("stone.png^mineral_iron.png");
- sourcelist.push_back("mud.png^mineral_coal.png");
- sourcelist.push_back("mud.png^mineral_iron.png");
- sourcelist.push_back("sand.png^mineral_coal.png");
- sourcelist.push_back("sand.png^mineral_iron.png");
+ core::map<std::string, bool> sourcelist;
+
+ for(u16 j=0; j<MAX_CONTENT+1; j++)
+ {
+ if(j == CONTENT_IGNORE || j == CONTENT_AIR)
+ continue;
+ const ContentFeatures &f = ndef->get(j);
+ for(std::set<std::string>::const_iterator
+ i = f.used_texturenames.begin();
+ i != f.used_texturenames.end(); i++)
+ {
+ std::string name = *i;
+ sourcelist[name] = true;
+
+ if(f.often_contains_mineral){
+ for(int k=1; k<MINERAL_COUNT; k++){
+ std::string mineraltexture = mineral_block_texture(k);
+ std::string fulltexture = name + "^" + mineraltexture;
+ sourcelist[fulltexture] = true;
+ }
+ }
+ }
+ }
+ infostream<<"Creating texture atlas out of textures: ";
+ for(core::map<std::string, bool>::Iterator
+ i = sourcelist.getIterator();
+ i.atEnd() == false; i++)
+ {
+ std::string name = i.getNode()->getKey();
+ infostream<<"\""<<name<<"\" ";
+ }
+ infostream<<std::endl;
+
// Padding to disallow texture bleeding
s32 padding = 16;
+ s32 column_width = 256;
+ s32 column_padding = 16;
+
/*
First pass: generate almost everything
*/
core::position2d<s32> pos_in_atlas(0,0);
- pos_in_atlas.Y += padding;
+ pos_in_atlas.Y = padding;
- for(u32 i=0; i<sourcelist.size(); i++)
+ for(core::map<std::string, bool>::Iterator
+ i = sourcelist.getIterator();
+ i.atEnd() == false; i++)
{
- std::string name = sourcelist[i];
+ std::string name = i.getNode()->getKey();
/*video::IImage *img = driver->createImageFromFile(
getTexturePath(name.c_str()).c_str());
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;
+ infostream<<"TextureSource::buildMainAtlas(): Couldn't generate texture atlas: Couldn't generate image \""<<name<<"\""<<std::endl;
continue;
}
if(dim.Width > max_size_in_atlas.Width
|| dim.Height > max_size_in_atlas.Height)
{
- dstream<<"INFO: TextureSource::buildMainAtlas(): Not adding "
+ infostream<<"TextureSource::buildMainAtlas(): Not adding "
<<"\""<<name<<"\" because image is large"<<std::endl;
continue;
}
- // Stop making atlas if atlas is full
+ // Wrap columns and 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;
+ if(pos_in_atlas.X > (s32)atlas_dim.Width - 256 - padding){
+ errorstream<<"TextureSource::buildMainAtlas(): "
+ <<"Atlas is full, not adding more textures."
+ <<std::endl;
+ break;
+ }
+ pos_in_atlas.Y = padding;
+ pos_in_atlas.X += column_width + column_padding;
}
+ infostream<<"TextureSource::buildMainAtlas(): Adding \""<<name
+ <<"\" to texture atlas"<<std::endl;
+
// Tile it a few times in the X direction
- u16 xwise_tiling = 16;
+ u16 xwise_tiling = column_width / dim.Width;
+ if(xwise_tiling > 16) // Limit to 16 (more gives no benefit)
+ xwise_tiling = 16;
for(u32 j=0; j<xwise_tiling; j++)
{
// Copy the copy to the atlas
dst_y = -y0 + pos_in_atlas.Y-1;
src_y = pos_in_atlas.Y;
}
- s32 x = x0 + pos_in_atlas.X * dim.Width;
+ s32 x = x0 + pos_in_atlas.X;
video::SColor c = atlas_img->getPixel(x, src_y);
atlas_img->setPixel(x,dst_y,c);
}
Add texture to caches
*/
- // Get next id
+ bool reuse_old_id = false;
u32 id = m_atlaspointer_cache.size();
+ // Check old id without fetching a texture
+ core::map<std::string, u32>::Node *n;
+ n = m_name_to_id.find(name);
+ // If it exists, we will replace the old definition
+ if(n){
+ id = n->getValue();
+ reuse_old_id = true;
+ }
+ infostream<<"TextureSource::buildMainAtlas(): "
+ <<"Replacing old AtlasPointer"<<std::endl;
// Create AtlasPointer
AtlasPointer ap(id);
// Create SourceAtlasPointer and add to containers
SourceAtlasPointer nap(name, ap, atlas_img, pos_in_atlas, dim);
- m_atlaspointer_cache.push_back(nap);
- m_name_to_id.insert(name, id);
+ if(reuse_old_id)
+ m_atlaspointer_cache[id] = nap;
+ else
+ m_atlaspointer_cache.push_back(nap);
+ m_name_to_id[name] = id;
// Increment position
pos_in_atlas.Y += dim.Height + padding * 2;
/*
Second pass: set texture pointer in generated AtlasPointers
*/
- for(u32 i=0; i<sourcelist.size(); i++)
+ for(core::map<std::string, bool>::Iterator
+ i = sourcelist.getIterator();
+ i.atEnd() == false; i++)
{
- std::string name = sourcelist[i];
+ std::string name = i.getNode()->getKey();
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;
+ //infostream<<"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,
- getTexturePath("main_atlas.png").c_str());*/
+ /*std::string atlaspath = porting::path_userdata
+ + DIR_DELIM + "generated_texture_atlas.png";
+ infostream<<"Removing and writing texture atlas for inspection to "
+ <<atlaspath<<std::endl;
+ fs::RecursiveDelete(atlaspath);
+ driver->writeImageToFile(atlas_img, atlaspath.c_str());*/
}
video::IImage* generate_image_from_scratch(std::string name,
IrrlichtDevice *device)
{
- dstream<<"INFO: generate_image_from_scratch(): "
- "name="<<name<<std::endl;
+ /*infostream<<"generate_image_from_scratch(): "
+ "\""<<name<<"\""<<std::endl;*/
video::IVideoDriver* driver = device->getVideoDriver();
assert(driver);
}
}
- /*dstream<<"INFO: generate_image_from_scratch(): "
+ /*infostream<<"generate_image_from_scratch(): "
<<"last_separator_position="<<last_separator_position
<<std::endl;*/
{
// Construct base 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;
+ /*infostream<<"generate_image_from_scratch(): Calling itself recursively"
+ " to get base image of \""<<name<<"\" = \""
+ <<base_image_name<<"\""<<std::endl;*/
baseimg = generate_image_from_scratch(base_image_name, device);
}
*/
std::string last_part_of_name = name.substr(last_separator_position+1);
- dstream<<"last_part_of_name="<<last_part_of_name<<std::endl;
+ //infostream<<"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, device) == false)
{
- dstream<<"INFO: generate_image_from_scratch(): "
+ infostream<<"generate_image_from_scratch(): "
"failed to generate \""<<last_part_of_name<<"\""
<<std::endl;
return NULL;
{
// A normal texture; load it from a file
std::string path = getTexturePath(part_of_name.c_str());
- dstream<<"INFO: getTextureIdDirect(): Loading path \""<<path
- <<"\""<<std::endl;
+ /*infostream<<"generate_image(): Loading path \""<<path
+ <<"\""<<std::endl;*/
video::IImage *image = driver->createImageFromFile(path.c_str());
if(image == NULL)
{
- dstream<<"WARNING: Could not load image \""<<part_of_name
- <<"\" from path \""<<path<<"\""
+ infostream<<"generate_image(): Could not load image \""
+ <<part_of_name<<"\" from path \""<<path<<"\""
<<" while building texture"<<std::endl;
//return false;
- dstream<<"WARNING: Creating a dummy"<<" image for \""
- <<part_of_name<<"\""<<std::endl;
+ infostream<<"generate_image(): Creating a dummy"
+ <<" image for \""<<part_of_name<<"\""<<std::endl;
// Just create a dummy image
//core::dimension2d<u32> dim(2,2);
// If base image is NULL, load as base.
if(baseimg == NULL)
{
- dstream<<"INFO: Setting "<<part_of_name<<" as base"<<std::endl;
+ //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
// Else blit on base.
else
{
- dstream<<"INFO: Blitting "<<part_of_name<<" on base"<<std::endl;
+ //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);
{
// A special texture modification
- dstream<<"INFO: getTextureIdDirect(): generating special "
+ infostream<<"generate_image(): generating special "
<<"modification \""<<part_of_name<<"\""
<<std::endl;
{
if(baseimg == NULL)
{
- dstream<<"WARNING: getTextureIdDirect(): baseimg==NULL "
- <<"for part_of_name="<<part_of_name
- <<", cancelling."<<std::endl;
+ infostream<<"generate_image(): baseimg==NULL "
+ <<"for part_of_name=\""<<part_of_name
+ <<"\", cancelling."<<std::endl;
return false;
}
sf.next(":");
u32 w0 = stoi(sf.next("x"));
u32 h0 = stoi(sf.next(":"));
- dstream<<"INFO: combined w="<<w0<<" h="<<h0<<std::endl;
+ infostream<<"combined w="<<w0<<" h="<<h0<<std::endl;
core::dimension2d<u32> dim(w0,h0);
baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
while(sf.atend() == false)
u32 x = stoi(sf.next(","));
u32 y = stoi(sf.next("="));
std::string filename = sf.next(":");
- dstream<<"INFO: Adding \""<<filename
+ infostream<<"Adding \""<<filename
<<"\" to combined ("<<x<<","<<y<<")"
<<std::endl;
video::IImage *img = driver->createImageFromFile(
if(img)
{
core::dimension2d<u32> dim = img->getDimension();
- dstream<<"INFO: Size "<<dim.Width
+ infostream<<"Size "<<dim.Width
<<"x"<<dim.Height<<std::endl;
core::position2d<s32> pos_base(x, y);
video::IImage *img2 =
}
else
{
- dstream<<"WARNING: img==NULL"<<std::endl;
+ infostream<<"img==NULL"<<std::endl;
}
}
}
{
if(baseimg == NULL)
{
- dstream<<"WARNING: getTextureIdDirect(): baseimg==NULL "
- <<"for part_of_name="<<part_of_name
- <<", cancelling."<<std::endl;
+ infostream<<"generate_image(): baseimg==NULL "
+ <<"for part_of_name=\""<<part_of_name
+ <<"\", cancelling."<<std::endl;
return false;
}
{
if(baseimg != NULL)
{
- dstream<<"WARNING: getTextureIdDirect(): baseimg!=NULL "
- <<"for part_of_name="<<part_of_name
- <<", cancelling."<<std::endl;
+ infostream<<"generate_image(): baseimg!=NULL "
+ <<"for part_of_name=\""<<part_of_name
+ <<"\", cancelling."<<std::endl;
return false;
}
std::string path = getTexturePath(filename.c_str());
- dstream<<"INFO: getTextureIdDirect(): Loading path \""<<path
+ infostream<<"generate_image(): Loading path \""<<path
<<"\""<<std::endl;
video::IImage *image = driver->createImageFromFile(path.c_str());
if(image == NULL)
{
- dstream<<"WARNING: getTextureIdDirect(): Loading path \""
+ infostream<<"generate_image(): Loading path \""
<<path<<"\" failed"<<std::endl;
}
else
image->drop();
}
}
+ /*
+ "[makealpha:R,G,B:filename.png"
+ Use an image with converting one color to transparent.
+ */
+ else if(part_of_name.substr(0,11) == "[makealpha:")
+ {
+ if(baseimg != NULL)
+ {
+ infostream<<"generate_image(): 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("");
+
+ std::string path = getTexturePath(filename.c_str());
+
+ infostream<<"generate_image(): Loading path \""<<path
+ <<"\""<<std::endl;
+
+ video::IImage *image = driver->createImageFromFile(path.c_str());
+
+ if(image == NULL)
+ {
+ infostream<<"generate_image(): Loading path \""
+ <<path<<"\" failed"<<std::endl;
+ }
+ else
+ {
+ core::dimension2d<u32> dim = image->getDimension();
+ baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
+
+ // Blit
+ image->copyTo(baseimg);
+
+ image->drop();
+
+ 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);
+ }
+ }
+ }
+ /*
+ "[makealpha2:R,G,B;R2,G2,B2:filename.png"
+ Use an image with converting two colors to transparent.
+ */
+ else if(part_of_name.substr(0,12) == "[makealpha2:")
+ {
+ if(baseimg != NULL)
+ {
+ infostream<<"generate_image(): baseimg!=NULL "
+ <<"for part_of_name=\""<<part_of_name
+ <<"\", cancelling."<<std::endl;
+ return false;
+ }
+
+ Strfnd sf(part_of_name.substr(12));
+ u32 r1 = stoi(sf.next(","));
+ u32 g1 = stoi(sf.next(","));
+ u32 b1 = stoi(sf.next(";"));
+ u32 r2 = stoi(sf.next(","));
+ u32 g2 = stoi(sf.next(","));
+ u32 b2 = stoi(sf.next(":"));
+ std::string filename = sf.next("");
+
+ std::string path = getTexturePath(filename.c_str());
+
+ infostream<<"generate_image(): Loading path \""<<path
+ <<"\""<<std::endl;
+
+ video::IImage *image = driver->createImageFromFile(path.c_str());
+
+ if(image == NULL)
+ {
+ infostream<<"generate_image(): Loading path \""
+ <<path<<"\" failed"<<std::endl;
+ }
+ else
+ {
+ core::dimension2d<u32> dim = image->getDimension();
+ baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
+
+ // Blit
+ image->copyTo(baseimg);
+
+ image->drop();
+
+ 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) &&
+ !(r == r2 && g == g2 && b == b2))
+ continue;
+ c.setAlpha(0);
+ baseimg->setPixel(x,y,c);
+ }
+ }
+ }
/*
[inventorycube{topimage{leftimage{rightimage
In every subimage, replace ^ with &.
{
if(baseimg != NULL)
{
- dstream<<"WARNING: getTextureIdDirect(): baseimg!=NULL "
- <<"for part_of_name="<<part_of_name
- <<", cancelling."<<std::endl;
+ infostream<<"generate_image(): baseimg!=NULL "
+ <<"for part_of_name=\""<<part_of_name
+ <<"\", cancelling."<<std::endl;
return false;
}
if(driver->queryFeature(video::EVDF_RENDER_TO_TARGET) == false)
{
- dstream<<"WARNING: getTextureIdDirect(): EVDF_RENDER_TO_TARGET"
+ infostream<<"generate_image(): EVDF_RENDER_TO_TARGET"
" not supported. Creating fallback image"<<std::endl;
baseimg = generate_image_from_scratch(
imagename_top, device);
u32 w0 = 64;
u32 h0 = 64;
- dstream<<"INFO: inventorycube w="<<w0<<" h="<<h0<<std::endl;
+ //infostream<<"inventorycube w="<<w0<<" h="<<h0<<std::endl;
core::dimension2d<u32> dim(w0,h0);
// Generate images for the faces of the cube
}
else
{
- dstream<<"WARNING: getTextureIdDirect(): Invalid "
+ infostream<<"generate_image(): Invalid "
" modification: \""<<part_of_name<<"\""<<std::endl;
}
}