/*
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
#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),
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()
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
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
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<<"\""
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");
sourcelist.push_back("sand.png^mineral_iron.png");
// Padding to disallow texture bleeding
- s32 padding = 8;
+ s32 padding = 16;
/*
First pass: generate almost everything
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;
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;
}
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;
Write image to file so that it can be inspected
*/
/*driver->writeImageToFile(atlas_img,
- porting::getDataPath("main_atlas.png").c_str());*/
+ 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
*/
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);
}
/*
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<<"\""
}
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;
<<", 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();
}
}
/*
<<"\" 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();
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;
return false;
}
- // This is just a placeholder
-
str_replace_char(part_of_name, '&', '^');
Strfnd sf(part_of_name);
sf.next("{");
std::string imagename_left = sf.next("{");
std::string imagename_right = sf.next("{");
- baseimg = generate_image_from_scratch(
- imagename_top, driver);
-
+#if 1
//TODO
-#if 0
+
if(driver->queryFeature(video::EVDF_RENDER_TO_TARGET) == false)
{
dstream<<"WARNING: getTextureIdDirect(): EVDF_RENDER_TO_TARGET"
- " not supported"<<std::endl;
- return false;
+ " not supported. Creating fallback image"<<std::endl;
+ baseimg = generate_image_from_scratch(
+ imagename_top, device);
+ return true;
}
- u32 w0 = 16;
- u32 h0 = 16;
+ u32 w0 = 64;
+ u32 h0 = 64;
dstream<<"INFO: inventorycube w="<<w0<<" h="<<h0<<std::endl;
core::dimension2d<u32> dim(w0,h0);
-
- //baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
-
+
+ // Generate images for the faces of the cube
video::IImage *img_top = generate_image_from_scratch(
- imagename_top, driver);
+ imagename_top, device);
video::IImage *img_left = generate_image_from_scratch(
- imagename_left, driver);
+ imagename_left, device);
video::IImage *img_right = generate_image_from_scratch(
- imagename_right, driver);
+ 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);
- // Render target texture
+ // 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());
+ 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);
- img_top->drop();
- img_left->drop();
- img_right->drop();
+ /*
+ 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();
- //TODO
- assert(0);
+ // 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
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);