last_dot_i = i;
break;
}
-
+
if(path[i] == '\\' || path[i] == '/')
break;
}
return path;
}
while((++ext) != NULL);
-
+
return "";
}
bool incache = g_texturename_to_path_cache.get(filename, &fullpath);
if(incache)
return fullpath;
-
+
/*
Check from texture_path
*/
// 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;
}
getTextureId("stone.png^mineral_coal.png^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"
// 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 ¶ms);
-
+
// Generates an image from a full string like
// "stone.png^mineral_coal.png^[crack:1:0".
// Shall be called from the main thread.
bool generateImage(std::string part_of_name, video::IImage *& baseimg);
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;
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;
m_device(device)
{
assert(m_device);
-
- m_textureinfo_cache_mutex.Init();
-
+
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
return n->second;
}
}
-
+
/*
Get texture
*/
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;
-
+ 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;
-
+
+ /*infostream<<"Waiting for texture from main thread, name=\""
+ <<name<<"\""<<std::endl;*/
+
try
{
- // Wait result for a second
- GetResult<std::string, u32, u8, u8>
+ while(true) {
+ // Wait result for a second
+ GetResult<std::string, u32, u8, u8>
result = result_queue.pop_front(1000);
-
- // Check that at least something worked OK
- assert(result.key == name);
- return result.item;
+ if (result.key == name) {
+ return result.item;
+ }
+ }
}
catch(ItemNotFoundException &e)
{
- infostream<<"Waiting for texture timed out."<<std::endl;
+ errorstream<<"Waiting for texture " << name << " timed out."<<std::endl;
return 0;
}
}
-
+
infostream<<"getTextureId(): Failed"<<std::endl;
return 0;
infostream<<"getTextureIdDirect(): name is empty"<<std::endl;
return 0;
}
-
+
/*
Calling only allowed from main thread
*/
/*infostream<<"getTextureIdDirect(): \""<<name
<<"\" NOT found in cache. Creating it."<<std::endl;*/
-
+
/*
Get the base image
*/
is made.
*/
u32 base_image_id = 0;
-
+
// Find last meta separator in name
s32 last_separator_position = -1;
for(s32 i=name.size()-1; i>=0; i--)
<<base_image_name<<"\""<<std::endl;*/
base_image_id = getTextureIdDirect(base_image_name);
}
-
+
//infostream<<"base_image_id="<<base_image_id<<std::endl;
-
+
video::IVideoDriver* driver = m_device->getVideoDriver();
assert(driver);
An image will be built from files and then converted into a texture.
*/
video::IImage *baseimg = NULL;
-
+
// If a base image was found, copy it to baseimg
if(base_image_id != 0)
{
JMutexAutoLock lock(m_textureinfo_cache_mutex);
TextureInfo *ti = &m_textureinfo_cache[base_image_id];
-
+
if(ti->img == NULL)
{
infostream<<"getTextureIdDirect(): WARNING: NULL image in "
<<std::endl;*/
}
}
-
+
/*
Parse out the last part of the name of the image and act
according to it
errorstream<<"getTextureIdDirect(): baseimg is NULL (attempted to"
" create texture \""<<name<<"\""<<std::endl;
}
-
+
if(baseimg != NULL)
{
// Create texture from resulting image
t = driver->addTexture(name.c_str(), baseimg);
}
-
+
/*
Add texture to caches (add NULL textures too)
*/
JMutexAutoLock lock(m_textureinfo_cache_mutex);
-
+
u32 id = m_textureinfo_cache.size();
TextureInfo ti(name, t, baseimg);
m_textureinfo_cache.push_back(ti);
m_name_to_id[name] = id;
- /*infostream<<"getTextureIdDirect(): "
- <<"Returning id="<<id<<" for name \""<<name<<"\""<<std::endl;*/
-
return id;
}
<<m_textureinfo_cache.size()<<std::endl;
return "";
}
-
+
return m_textureinfo_cache[id].name;
}
/*
Fetch textures
*/
+ //NOTE this is only thread safe for ONE consumer thread!
if(!m_get_texture_queue.empty())
{
GetRequest<std::string, u32, u8, u8>
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);
}
base_image_name = name.substr(0, last_separator_position);
baseimg = generateImageFromScratch(base_image_name);
}
-
+
/*
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_position+1);
-
+
// Generate image according to part of name
if(!generateImage(last_part_of_name, baseimg))
{
<<std::endl;
return NULL;
}
-
+
return baseimg;
}
{
video::IImage *image = m_sourcecache.getOrLoad(part_of_name, m_device);
- if(image == NULL)
- {
- if(part_of_name != ""){
- errorstream<<"generateImage(): Could not load image \""
+ if (image != NULL) {
+ if (!driver->queryFeature(irr::video::EVDF_TEXTURE_NPOT)) {
+ core::dimension2d<u32> dim = image->getDimension();
+
+
+ if ((dim.Height %2 != 0) ||
+ (dim.Width %2 != 0)) {
+ infostream << "TextureSource::generateImage "
+ << part_of_name << " size npot2 x=" << dim.Width
+ << " y=" << dim.Height << std::endl;
+ }
+ }
+ }
+
+ 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"
+ 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
//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
+ Otherwise images with alpha cannot be blitted on
images that don't have alpha in the original file.
*/
core::dimension2d<u32> dim = image->getDimension();
/*infostream<<"generateImage(): generating special "
<<"modification \""<<part_of_name<<"\""
<<std::endl;*/
-
+
/*
[crack:N:P
[cracko:N:P
"[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
+ 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")
}
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++)
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);
img_top->drop();
img_left->drop();
img_right->drop();
-
+
/*
Draw a cube mesh into a render target texture
*/
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();
driver->removeTexture(texture_top);
driver->removeTexture(texture_left);
driver->removeTexture(texture_right);
-
+
if(rtt == NULL)
{
baseimg = generateImageFromScratch(imagename_top);
<<"\", cancelling."<<std::endl;
return false;
}
-
+
v2u32 frame_size = baseimg->getDimension();
frame_size.Y /= frame_count;
{
if(image == NULL)
return;
-
+
core::dimension2d<u32> dim = image->getDimension();
for(u32 y=0; y<dim.Height; y++)
{
if(src == NULL || dst == NULL)
return;
-
+
core::dimension2d<u32> srcdim = src->getDimension();
core::dimension2d<u32> dstdim = dst->getDimension();
projects / dragonfireclient.git / blobdiff