mirror of https://github.com/minetest/minetest.git
453 lines
11 KiB
C++
453 lines
11 KiB
C++
#include "irrlichtwrapper.h"
|
|
#include "constants.h"
|
|
#include "string.h"
|
|
#include "strfnd.h"
|
|
|
|
IrrlichtWrapper::IrrlichtWrapper(IrrlichtDevice *device)
|
|
{
|
|
m_running = true;
|
|
m_main_thread = get_current_thread_id();
|
|
m_device_mutex.Init();
|
|
m_device = device;
|
|
}
|
|
|
|
IrrlichtWrapper::~IrrlichtWrapper()
|
|
{
|
|
#if 0
|
|
// Clear image cache
|
|
for(core::map<std::string, video::IImage*>::Iterator
|
|
i = m_imagecache.getIterator();
|
|
i.atEnd() == false; i++)
|
|
{
|
|
i.getNode()->getValue()->drop();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void IrrlichtWrapper::Run()
|
|
{
|
|
#if 0
|
|
/*
|
|
Fetch textures
|
|
*/
|
|
if(m_get_texture_queue.size() > 0)
|
|
{
|
|
GetRequest<TextureSpec, video::ITexture*, u8, u8>
|
|
request = m_get_texture_queue.pop();
|
|
|
|
dstream<<"got texture request with"
|
|
<<" key.tids[0]="<<request.key.tids[0]
|
|
<<" [1]="<<request.key.tids[1]
|
|
<<std::endl;
|
|
|
|
GetResult<TextureSpec, video::ITexture*, u8, u8>
|
|
result;
|
|
result.key = request.key;
|
|
result.callers = request.callers;
|
|
result.item = getTextureDirect(request.key);
|
|
|
|
request.dest->push_back(result);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void IrrlichtWrapper::Shutdown(bool shutdown)
|
|
{
|
|
m_running = !shutdown;
|
|
}
|
|
|
|
IrrlichtDevice* IrrlichtWrapper::getDevice()
|
|
{
|
|
if(get_current_thread_id() != m_main_thread)
|
|
{
|
|
dstream<<"WARNING: IrrlichtWrapper::getDevice() called "
|
|
"not from main thread"<<std::endl;
|
|
return NULL;
|
|
}
|
|
return m_device;
|
|
}
|
|
|
|
#if 0
|
|
textureid_t IrrlichtWrapper::getTextureId(const std::string &name)
|
|
{
|
|
u32 id = m_namecache.getId(name);
|
|
return id;
|
|
}
|
|
|
|
std::string IrrlichtWrapper::getTextureName(textureid_t id)
|
|
{
|
|
std::string name("");
|
|
m_namecache.getValue(id, name);
|
|
// In case it was found, return the name; otherwise return an empty name.
|
|
return name;
|
|
}
|
|
|
|
video::ITexture* IrrlichtWrapper::getTexture(const std::string &filename)
|
|
{
|
|
TextureSpec spec(getTextureId(filename));
|
|
return getTexture(spec);
|
|
}
|
|
|
|
video::ITexture* IrrlichtWrapper::getTexture(const TextureSpec &spec)
|
|
{
|
|
if(spec.empty())
|
|
return NULL;
|
|
|
|
video::ITexture *t = m_texturecache.get(spec);
|
|
if(t != NULL)
|
|
return t;
|
|
|
|
if(get_current_thread_id() == m_main_thread)
|
|
{
|
|
dstream<<"Getting texture directly: spec.tids[0]="
|
|
<<spec.tids[0]<<std::endl;
|
|
|
|
t = getTextureDirect(spec);
|
|
}
|
|
else
|
|
{
|
|
// If irrlicht has shut down, just return NULL
|
|
if(m_running == false)
|
|
return NULL;
|
|
|
|
// We're gonna ask the result to be put into here
|
|
ResultQueue<TextureSpec, video::ITexture*, u8, u8> result_queue;
|
|
|
|
// Throw a request in
|
|
m_get_texture_queue.add(spec, 0, 0, &result_queue);
|
|
|
|
dstream<<"Waiting for texture from main thread: spec.tids[0]="
|
|
<<spec.tids[0]<<std::endl;
|
|
|
|
try
|
|
{
|
|
// Wait result for a second
|
|
GetResult<TextureSpec, video::ITexture*, u8, u8>
|
|
result = result_queue.pop_front(1000);
|
|
|
|
// Check that at least something worked OK
|
|
assert(result.key == spec);
|
|
|
|
t = result.item;
|
|
}
|
|
catch(ItemNotFoundException &e)
|
|
{
|
|
dstream<<"Waiting for texture timed out."<<std::endl;
|
|
t = NULL;
|
|
}
|
|
}
|
|
|
|
// Add to cache and return
|
|
m_texturecache.set(spec, t);
|
|
return t;
|
|
}
|
|
|
|
// Draw a progress bar on the image
|
|
void make_progressbar(float value, video::IImage *image);
|
|
|
|
/*
|
|
Texture fetcher/maker function, called always from the main thread
|
|
*/
|
|
|
|
video::ITexture* IrrlichtWrapper::getTextureDirect(const TextureSpec &spec)
|
|
{
|
|
// This would result in NULL image
|
|
if(spec.empty())
|
|
return NULL;
|
|
|
|
// Don't generate existing stuff
|
|
video::ITexture *t = m_texturecache.get(spec);
|
|
if(t != NULL)
|
|
{
|
|
dstream<<"WARNING: Existing stuff requested from "
|
|
"getTextureDirect()"<<std::endl;
|
|
return t;
|
|
}
|
|
|
|
video::IVideoDriver* driver = m_device->getVideoDriver();
|
|
|
|
/*
|
|
An image will be built from files and then converted into a texture.
|
|
*/
|
|
video::IImage *baseimg = NULL;
|
|
|
|
/*
|
|
Irrlicht requires a name for every texture, with which it
|
|
will be stored internally in irrlicht.
|
|
*/
|
|
std::string texture_name;
|
|
|
|
for(u32 i=0; i<TEXTURE_SPEC_TEXTURE_COUNT; i++)
|
|
{
|
|
textureid_t tid = spec.tids[i];
|
|
if(tid == 0)
|
|
continue;
|
|
|
|
std::string name = getTextureName(tid);
|
|
|
|
// Add something to the name so that it is a unique identifier.
|
|
texture_name += "[";
|
|
texture_name += name;
|
|
texture_name += "]";
|
|
|
|
/*
|
|
Try to get image from image cache
|
|
*/
|
|
{
|
|
core::map<std::string, video::IImage*>::Node *n;
|
|
n = m_imagecache.find(texture_name);
|
|
if(n != NULL)
|
|
{
|
|
video::IImage *image = n->getValue();
|
|
|
|
core::dimension2d<u32> dim = image->getDimension();
|
|
baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
|
|
image->copyTo(baseimg);
|
|
|
|
dstream<<"INFO: getTextureDirect(): Loaded \""
|
|
<<texture_name<<"\" from image cache"
|
|
<<std::endl;
|
|
|
|
// Do not process any further.
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Stuff starting with [ are special commands
|
|
if(name[0] != '[')
|
|
{
|
|
// A normal texture; load it from a file
|
|
std::string path = porting::getDataPath(name.c_str());
|
|
dstream<<"INFO: getTextureDirect(): Loading path \""<<path
|
|
<<"\""<<std::endl;
|
|
|
|
// DEBUG
|
|
/*{
|
|
dstream<<"DEBUG CODE: Loading base image "
|
|
"directly to texture"<<std::endl;
|
|
t = driver->getTexture(path.c_str());
|
|
driver->renameTexture(t, texture_name.c_str());
|
|
return t;
|
|
}*/
|
|
|
|
video::IImage *image = driver->createImageFromFile(path.c_str());
|
|
|
|
if(image == NULL)
|
|
{
|
|
dstream<<"WARNING: Could not load image \""<<name
|
|
<<"\" from path \""<<path<<"\""
|
|
<<" while building texture"<<std::endl;
|
|
continue;
|
|
}
|
|
|
|
// If base image is NULL, load as base.
|
|
if(baseimg == NULL)
|
|
{
|
|
dstream<<"INFO: Setting "<<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.
|
|
*/
|
|
// This is a deprecated method
|
|
//baseimg = driver->createImage(video::ECF_A8R8G8B8, image);
|
|
core::dimension2d<u32> dim = image->getDimension();
|
|
baseimg = driver->createImage(video::ECF_A8R8G8B8, dim);
|
|
image->copyTo(baseimg);
|
|
image->drop();
|
|
//baseimg = image;
|
|
}
|
|
// Else blit on base.
|
|
else
|
|
{
|
|
dstream<<"INFO: Blitting "<<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);
|
|
// Drop image
|
|
image->drop();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// A special texture modification
|
|
dstream<<"INFO: getTextureDirect(): generating \""<<name<<"\""
|
|
<<std::endl;
|
|
if(name.substr(0,6) == "[crack")
|
|
{
|
|
u16 progression = stoi(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());
|
|
|
|
if(crackimage)
|
|
{
|
|
/*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++)
|
|
{
|
|
// 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);
|
|
}
|
|
|
|
crackimage->drop();
|
|
}
|
|
}
|
|
else if(name.substr(0,8) == "[combine")
|
|
{
|
|
// "[combine:16x128:0,0=stone.png:0,16=grass.png"
|
|
Strfnd sf(name);
|
|
sf.next(":");
|
|
u32 w0 = stoi(sf.next("x"));
|
|
u32 h0 = stoi(sf.next(":"));
|
|
dstream<<"INFO: 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
|
|
<<"\" to combined ("<<x<<","<<y<<")"
|
|
<<std::endl;
|
|
video::IImage *img = driver->createImageFromFile(
|
|
porting::getDataPath(filename.c_str()).c_str());
|
|
if(img)
|
|
{
|
|
core::dimension2d<u32> dim = img->getDimension();
|
|
dstream<<"INFO: 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);
|
|
img2->drop();
|
|
}
|
|
else
|
|
{
|
|
dstream<<"WARNING: img==NULL"<<std::endl;
|
|
}
|
|
}
|
|
}
|
|
else if(name.substr(0,12) == "[progressbar")
|
|
{
|
|
float value = stof(name.substr(12));
|
|
make_progressbar(value, baseimg);
|
|
}
|
|
else
|
|
{
|
|
dstream<<"WARNING: getTextureDirect(): Invalid "
|
|
" texture: \""<<name<<"\""<<std::endl;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Add to image cache
|
|
*/
|
|
if(baseimg != NULL)
|
|
{
|
|
core::map<std::string, video::IImage*>::Node *n;
|
|
n = m_imagecache.find(texture_name);
|
|
if(n != NULL)
|
|
{
|
|
video::IImage *img = n->getValue();
|
|
if(img != baseimg)
|
|
{
|
|
img->drop();
|
|
}
|
|
}
|
|
|
|
m_imagecache[texture_name] = baseimg;
|
|
}
|
|
}
|
|
|
|
// If no resulting image, return NULL
|
|
if(baseimg == NULL)
|
|
{
|
|
dstream<<"WARNING: getTextureDirect(): baseimg is NULL (attempted to"
|
|
" create texture \""<<texture_name<<"\""<<std::endl;
|
|
return NULL;
|
|
}
|
|
|
|
/*// DEBUG: Paint some pixels
|
|
video::SColor c(255,255,0,0);
|
|
baseimg->setPixel(1,1, c);
|
|
baseimg->setPixel(1,14, c);
|
|
baseimg->setPixel(14,1, c);
|
|
baseimg->setPixel(14,14, c);*/
|
|
|
|
// Create texture from resulting image
|
|
t = driver->addTexture(texture_name.c_str(), baseimg);
|
|
|
|
dstream<<"INFO: getTextureDirect(): created texture \""<<texture_name
|
|
<<"\""<<std::endl;
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
void make_progressbar(float value, video::IImage *image)
|
|
{
|
|
if(image == NULL)
|
|
return;
|
|
|
|
core::dimension2d<u32> size = image->getDimension();
|
|
|
|
u32 barheight = 1;
|
|
u32 barpad_x = 1;
|
|
u32 barpad_y = 1;
|
|
u32 barwidth = size.Width - barpad_x*2;
|
|
v2u32 barpos(barpad_x, size.Height - barheight - barpad_y);
|
|
|
|
u32 barvalue_i = (u32)(((float)barwidth * value) + 0.5);
|
|
|
|
video::SColor active(255,255,0,0);
|
|
video::SColor inactive(255,0,0,0);
|
|
for(u32 x0=0; x0<barwidth; x0++)
|
|
{
|
|
video::SColor *c;
|
|
if(x0 < barvalue_i)
|
|
c = &active;
|
|
else
|
|
c = &inactive;
|
|
u32 x = x0 + barpos.X;
|
|
for(u32 y=barpos.Y; y<barpos.Y+barheight; y++)
|
|
{
|
|
image->setPixel(x,y, *c);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|