irr::video::ITexture* EffectHandler::generateRandomVectorTexture(const irr::core::dimension2du& dimensions,
const irr::core::stringc& name)
{
IImage* tmpImage = driver->createImage(irr::video::ECF_A8R8G8B8, dimensions);
srand(device->getTimer()->getRealTime());
for (u32 x = 0; x < dimensions.Width; ++x)
{
for (u32 y = 0; y < dimensions.Height; ++y)
{
vector3df randVec;
// Reject vectors outside the unit sphere to get a uniform distribution.
do
{
randVec = vector3df((f32)rand() / (f32)RAND_MAX, (f32)rand() / (f32)RAND_MAX, (f32)rand() / (f32)RAND_MAX);
}
while (randVec.getLengthSQ() > 1.0f);
const SColorf randCol(randVec.X, randVec.Y, randVec.Z);
tmpImage->setPixel(x, y, randCol.toSColor());
}
}
ITexture* randTexture = driver->addTexture(name, tmpImage);
tmpImage->drop();
return randTexture;
}
// ----------------------------------------------------------------------------
CMeshBuffer<S3DVertex2TCoords>* Terrain::build(path p)
{
IrrlichtDevice* device = Editor::getEditor()->getDevice();
CMeshBuffer<S3DVertex2TCoords>* mb = new CMeshBuffer<S3DVertex2TCoords>();
mb->Vertices.reallocate(m_mesh.vertex_count);
mb->Indices.reallocate(m_mesh.quad_count * 6);
for (u32 i = 0; i < m_mesh.vertex_count; i++)
mb->Vertices.push_back(m_mesh.vertices[i]);
for (u32 i = 0; i < m_mesh.quad_count * 6; i++)
mb->Indices.push_back(m_mesh.indices[i]);
mb->recalculateBoundingBox();
mb->Material = m_material;
ITexture* texture = m_material.getTexture(1);
IImage* image = device->getVideoDriver()->createImage(texture, position2di(0, 0),
texture->getSize());
stringc name = p + "/splatt.png";
device->getVideoDriver()->writeImageToFile(image, name.c_str());
image->drop();
return mb;
} // build
static BOOL drawImage(HDC hDC, LPCTSTR lpszFileName)
{
IImagingFactory* pImageFactory = NULL;
BOOL bRet = FALSE;
if (SUCCEEDED(CoCreateInstance(CLSID_ImagingFactory,
0, CLSCTX_INPROC_SERVER, IID_IImagingFactory, (void**)&pImageFactory)))
{
IImage* pImage = NULL;
ImageInfo imageInfo;
if (SUCCEEDED(pImageFactory->CreateImageFromFile(lpszFileName, &pImage))
&& SUCCEEDED(pImage->GetImageInfo(&imageInfo)))
{
RECT rect = {0, 0, imageInfo.Width, imageInfo.Height};
pImage->Draw(hDC, &rect, 0);
pImage->Release();
bRet = TRUE;
}
pImageFactory->Release();
}
return bRet;
}
static PyObject *
image_set_offset(PyObject *self, PyObject *args)
{
int x, y;
PyObject *pyim;
if(!PyArg_ParseTuple(args,"Oii",&pyim,&x,&y))
{
return NULL;
}
IImage *i = (IImage *)PyCObject_AsVoidPtr(pyim);
if(NULL == i)
{
return NULL;
}
bool ok = i->set_offset(x,y);
if(!ok)
{
PyErr_SetString(PyExc_ValueError, "Offset out of bounds");
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
//! creates a surface from the file
IImage* CImageLoaderDDS::loadImage(io::IReadFile* file) const
{
u8 *memFile = new u8 [ file->getSize() ];
file->read ( memFile, file->getSize() );
ddsBuffer *header = (ddsBuffer*) memFile;
IImage* image = 0;
s32 width, height;
eDDSPixelFormat pixelFormat;
if ( 0 == DDSGetInfo( header, &width, &height, &pixelFormat) )
{
image = new CImage(ECF_A8R8G8B8, core::dimension2d<u32>(width, height));
if ( DDSDecompress( header, (u8*) image->lock() ) == -1)
{
image->unlock();
image->drop();
image = 0;
}
}
delete [] memFile;
if ( image )
image->unlock();
return image;
}
bool CPicture::CreateThumbnailFromSurface(const unsigned char *buffer, int width, int height, int stride, const std::string &thumbFile)
{
CLog::Log(LOGDEBUG, "cached image '%s' size %dx%d", CURL::GetRedacted(thumbFile).c_str(), width, height);
if (URIUtils::HasExtension(thumbFile, ".jpg"))
{
#if defined(HAS_OMXPLAYER)
if (COMXImage::CreateThumbnailFromSurface((BYTE *)buffer, width, height, XB_FMT_A8R8G8B8, stride, thumbFile.c_str()))
return true;
#endif
}
unsigned char *thumb = NULL;
unsigned int thumbsize=0;
IImage* pImage = ImageFactory::CreateLoader(thumbFile);
if(pImage == NULL || !pImage->CreateThumbnailFromSurface((BYTE *)buffer, width, height, XB_FMT_A8R8G8B8, stride, thumbFile.c_str(), thumb, thumbsize))
{
CLog::Log(LOGERROR, "Failed to CreateThumbnailFromSurface for %s", CURL::GetRedacted(thumbFile).c_str());
delete pImage;
return false;
}
XFILE::CFile file;
const bool ret = file.OpenForWrite(thumbFile, true) && file.Write(thumb, thumbsize) == thumbsize;
pImage->ReleaseThumbnailBuffer();
delete pImage;
return ret;
}
static PyObject *
image_resize(PyObject *self, PyObject *args)
{
int x, y;
int totalx=-1, totaly=-1;
PyObject *pyim;
if(!PyArg_ParseTuple(args,"Oiiii",&pyim,&x,&y,&totalx,&totaly))
{
return NULL;
}
IImage *i = (IImage *)PyCObject_AsVoidPtr(pyim);
if(NULL == i)
{
return NULL;
}
i->set_resolution(x,y,totalx,totaly);
if(! i->ok())
{
PyErr_SetString(PyExc_MemoryError, "Image too large");
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
void solveAndPaintOutput(int x0, int y0, int n, int mn,
Vector rgbVector[3], const SparseMatrix& matrix, Vector solutionVectors[3],
IImage& outputImage) {
for (int color = 0; color < 3; color++) {
cout << "Solving..."<<endl;
// solve equations set for current color
if (solveLinear(matrix, solutionVectors[color], rgbVector[color]) == 0) {
cout << "FAIL main(): matrix.solve() failed with color: "<<color<<endl;
return;
} else {
cout << "Done solving color "<<color<<endl;
}
// fill output image
for (int pixel = 0; pixel < mn; pixel++) {
int y = pixel / n;
int x = pixel - n * y;
int updateVal = (int)solutionVectors[color][pixel];
if (updateVal > 255) {
updateVal = 255;
}
else if (updateVal < 0) {
updateVal = 0;
}
int updatedRGBVal = getUpdatedRGBValue(outputImage.getRGB(x + x0, y + y0), updateVal, color);
outputImage.setRGB(x + x0, y + y0, updatedRGBVal);
}
cout<<"Done applying color "<<color<<" to output"<<endl;
}
}
static void DynamicLightParamAssign(const DynamicLightParam& other,
DynamicLightParam *self) {
IImage *old = self->image;
*self = other;
self->image->AddRef();
old->Release();
}
void Integral::IntegralScan(IImage& Source, IImage& Dest)
{
PrepareFor(Source);
CheckSameSize(Source, Dest);
CheckFloat(Dest);
uint Width = Source.Width();
uint Height = Source.Height();
Kernel(scan1, Source, Dest, Width, Height);
if (GetNbGroupsW(Source) > 1)
{
make_kernel<Image2D, Image2D>(SelectProgram(Dest), "scan2")
(EnqueueArgs(*m_CL, NDRange(GetNbGroupsW(Source) - 1, Source.Height())), Dest, *m_VerticalJunctions);
}
#undef KERNEL_RANGE
#define KERNEL_RANGE(src_img) src_img.FullRange()
Kernel(scan3, In(Dest, *m_VerticalJunctions), Dest);
if (GetNbGroupsH(Source) > 1)
{
make_kernel<Image2D, Image2D>(SelectProgram(Dest), "scan4")
(EnqueueArgs(*m_CL, NDRange(Source.Width(), GetNbGroupsH(Source) - 1)), Dest, *m_HorizontalJunctions);
}
Kernel(scan5, In(Dest, *m_HorizontalJunctions), Dest);
}
/*
Halflite Texture WAD
*/
IImage* CImageLoaderWAL2::loadImage(irr::io::IReadFile* file) const
{
miptex_halflife header;
file->seek(0);
file->read(&header, sizeof(header));
#ifdef __BIG_ENDIAN__
header.width = os::Byteswap::byteswap(header.width);
header.height = os::Byteswap::byteswap(header.height);
#endif
// palette
//u32 paletteofs = header.mipmap[0] + ((rawtexsize * 85) >> 6) + 2;
u32 *pal = new u32 [ 192 + 256 ];
u8 *s = (u8*) pal;
file->seek ( file->getSize() - 768 - 2 );
file->read ( s, 768 );
u32 i;
for ( i = 0; i < 256; ++i, s+= 3 )
{
pal [ 192 + i ] = 0xFF000000 | s[0] << 16 | s[1] << 8 | s[2];
}
ECOLOR_FORMAT format = ECF_R8G8B8;
// transparency in filename;-) funny. rgb:0x0000FF is colorkey
if ( file->getFileName().findFirst ( '{' ) >= 0 )
{
format = ECF_A8R8G8B8;
pal [ 192 + 255 ] &= 0x00FFFFFF;
}
u32 rawtexsize = header.width * header.height;
u8 *rawtex = new u8 [ rawtexsize ];
file->seek ( header.mipmap[0] );
file->read(rawtex, rawtexsize);
IImage* image = new CImage(format, core::dimension2d<u32>(header.width, header.height));
switch ( format )
{
case ECF_R8G8B8:
CColorConverter::convert8BitTo24Bit(rawtex, (u8*)image->getData(), header.width, header.height, (u8*) pal + 768, 0, false);
break;
case ECF_A8R8G8B8:
CColorConverter::convert8BitTo32Bit(rawtex, (u8*)image->getData(), header.width, header.height, (u8*) pal + 768, 0, false);
break;
}
delete [] rawtex;
delete [] pal;
return image;
}
Desktop::Desktop(ViewLogicGame& owner, IrrlichtDevice* pDevice)
: IGUIElement(EGUIET_ELEMENT, pDevice->getGUIEnvironment(), pDevice->getGUIEnvironment()->getRootGUIElement(), -1, core::rect<s32>(0, 0, 0, 0))
, m_owner(owner)
, m_pDevice(pDevice)
, m_pAppBar(NULL)
, m_pFontCourier(NULL)
, m_mutexApps(true)
, m_pSoftwareMgr(NULL)
, m_pItemMgr(NULL)
{
#ifdef _DEBUG
setDebugName("Desktop");
#endif//_DEBUG
// set the desktop dimensions
core::dimension2d<s32> screenRes = pDevice->getVideoDriver()->getScreenSize();
AbsoluteRect = core::rect<s32>(0, 0, screenRes.Width, screenRes.Height);
AbsoluteClippingRect = AbsoluteRect;
// load the desktop graphic and scale it as the wallpaper
IImage* pImg = m_pDevice->getVideoDriver()->createImageFromFile("./clientdata/desktop.jpg");
IImage* pImg2 = m_pDevice->getVideoDriver()->createImage(pImg->getColorFormat(), screenRes);
pImg->copyToScaling( pImg2 );
pImg->drop();
m_pBackground = m_pDevice->getVideoDriver()->addTexture("desktop", pImg2);
pImg2->drop();
// create the font(s)
m_pFontCourier = m_pDevice->getGUIEnvironment()->getFont("./clientdata/fonts/fontcourier.png");
// create the desktop app bar
m_pAppBar = new DesktopAppBar(Environment, this);
}
static PyObject *
image_create(PyObject *self, PyObject *args)
{
int x, y;
int totalx = -1, totaly = -1;
if(!PyArg_ParseTuple(args,"ii|ii",&x,&y,&totalx, &totaly))
{
return NULL;
}
IImage *i = new image();
#ifdef DEBUG_CREATION
printf("%p : IM : CTOR\n",i);
#endif
i->set_resolution(x,y,totalx, totaly);
if(! i->ok())
{
PyErr_SetString(PyExc_MemoryError, "Image too large");
delete i;
return NULL;
}
PyObject *pyret = PyCObject_FromVoidPtr(i,(void (*)(void *))image_delete);
return pyret;
}
/*!
quake2
*/
IImage* CImageLoaderWAL::loadImage(irr::io::IReadFile* file) const
{
miptex_quake2 header;
file->seek(0);
file->read(&header, sizeof(header));
#ifdef __BIG_ENDIAN__
header.width = os::Byteswap::byteswap(header.width);
header.height = os::Byteswap::byteswap(header.height);
#endif
u32 rawtexsize = header.width * header.height;
u8 *rawtex = new u8 [ rawtexsize ];
file->seek ( header.mipmap[0] );
file->read(rawtex, rawtexsize);
IImage* image = new CImage(ECF_A8R8G8B8, core::dimension2d<u32>(header.width, header.height));
CColorConverter::convert8BitTo32Bit(rawtex, (u8*)image->getData(), header.width, header.height, (u8*) colormap_pcx, 0, false);
delete [] rawtex;
return image;
}
IImage* createRainbowImage( u32 w, u32 h, u8 transparency, f64 gamma)
{
// create image
core::dimension2du size(w,h);
IImage* img = (IImage*)new CImage(ECF_A8R8G8B8, size);
if (!img) return 0;
size = img->getDimension();
// loop pixels per col
for (u32 y=0; y<size.Height; y++)
{
// calculate rainbow-color
SColor c = createRainbowColor( y, size.Height, gamma);
// set transparency
c.setAlpha(transparency);
// write one row with same color
for (u32 x=0; x<size.Width; x++)
{
// write rainbow-color
img->setPixel(x,y,c,false);
}
}
return img;
}
/*!
Quake1, Quake2, Hallife lmp texture
*/
IImage* CImageLoaderLMP::loadImage(irr::io::IReadFile* file) const
{
SLMPHeader header;
file->seek(0);
file->read(&header, sizeof(header));
// maybe palette file
u32 rawtexsize = header.width * header.height;
if ( rawtexsize + sizeof ( header ) != file->getSize() )
return 0;
u8 *rawtex = new u8 [ rawtexsize ];
file->read(rawtex, rawtexsize);
IImage* image = new CImage(ECF_A8R8G8B8, core::dimension2d<u32>(header.width, header.height));
CColorConverter::convert8BitTo32Bit(rawtex, (u8*)image->lock(), header.width, header.height, (u8*) colormap_h, 0, false);
image->unlock();
delete [] rawtex;
return image;
}
void PhysicsSim::addTerrain(stringw heightfield_file, stringw texture_file, Vector3D scale)
{
stringw filename = mediaDirectory + heightfield_file;
stringw texfilename = mediaDirectory + texture_file;
IImage* hfimg = driver->createImageFromFile (filename.c_str());
int img_width = hfimg->getDimension().Width;
int img_height = hfimg->getDimension().Height;
float xScale = scale.X, yScale = scale.Y, zScale = scale.Z;
ITerrainSceneNode* terrain = smgr->addTerrainSceneNode( filename.c_str(),
smgr->getRootSceneNode(), // parent node
-1, // node id
vector3df(0.f, 0.f, 0.f), // position
vector3df(0.f, 0.f, 0.f), // rotation
vector3df(1.f, 1.0f, 1.f), // scale
video::SColor ( 255, 255, 255, 255 ), // vertexColor
5, // maxLOD
ETPS_17, // patchSize
4 // smoothFactor
);
terrain->setMaterialTexture(0, driver->getTexture(texfilename.c_str()));
terrain->scaleTexture(200.0f, 0);
terrain->setScale(vector3df(xScale, yScale, zScale));
terrain->setPosition(vector3df(-((img_width-1.0)*xScale)/2.0, 0.0, -((img_height-1.0)*zScale)/2.0));
this->terrain = new Terrain(terrain, hfimg, Vector3D(xScale, yScale, zScale));
dynamicsWorld->addRigidBody(this->terrain->getRigidBody());
}
void CShowableAnim::blitImage(size_t frame, size_t group, SDL_Surface *to)
{
assert(to);
Rect src( xOffset, yOffset, pos.w, pos.h);
IImage * img = anim->getImage(frame, group);
if (img)
img->draw(to, pos.x-xOffset, pos.y-yOffset, &src, alpha);
}
//--------------------------------------------------------------------------------
void TemplateSimplePro::setEvent()
{
IImage* headImage = getLayout()->getImage("Image_Head");
assert(headImage);
headImage->getWidget()->setMouseButtonClickEvent(onMouseClickImagehead);
headImage->getWidget()->setMouseButtonPressedEvent(onMouseReleaseImagehead);
headImage->getWidget()->setToolTipsEvent(onTooltipsImagehead);
}
//--------------------------------------------------------------------------------
void TemplateSimplePro::onMouseClickImagehead( void* widget )
{
IImage* pMenu = (IImage*)widget;
if ( pMenu )
{
pMenu->setTexture("simpleHead.png");
TemplateSimplePro::getInstance().setClick();
}
}
bool Game::takescreenshot(){
// screenshot are taken without gamma!
IImage* image = device->getVideoDriver()->createScreenShot();
if (image)
{
device->getVideoDriver()->writeImageToFile(image, "screenshot.png", 100 );
image->drop();
}
}
void CAnimImage::showAll(SDL_Surface * to)
{
IImage *img;
if ( flags & CShowableAnim::BASE && frame != 0)
if ((img = anim->getImage(0, group)))
img->draw(to, pos.x, pos.y);
if ((img = anim->getImage(frame, group)))
img->draw(to, pos.x, pos.y);
}
//-------------------------------------
// Loads in a image from a file and returns it
// p1 in - pointer to the imagedata for the mesh
// rv - pointer IImage object and nullptr if failed
IImage *CRendererOpenGL::LoadImage(ImageData* id)
{
IImage *pImage = new CImageOpenGL();
if( !pImage->Load(id) )
{
delete pImage;
return nullptr;
}
m_vpImages.push_back(pImage);
return pImage;
}
void Camera::snapshot(const std::string& filename)
{
LOG_F_DEBUG("render", "Taking snapshot!");
IImage* img = mIrr.mpVideoDriver->createScreenShot();
if(!img)
LOG_F_ERROR("render", "Snapshot mage is null!");
else {
if (!mIrr.mpVideoDriver->writeImageToFile(img, filename.c_str()))
LOG_F_ERROR("render", "Could not write snapshot image!");
img->drop();
}
}
HBITMAP SHLoadImageFile( LPCTSTR pszFileName )
{
if ( !pszFileName || !*pszFileName )
return 0;
String strFileName = convertToStringA(pszFileName);
/*if ( String_endsWith(strFileName, ".bmp") )
{
return (HBITMAP)::LoadImage(NULL, pszFileName, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
}*/
if ( !String_endsWith(strFileName, ".png") && !String_endsWith(strFileName, ".bmp") )
return 0;
IImagingFactory *pImgFactory = NULL;
IImage *pImage = NULL;
//CoInitializeEx(NULL, COINIT_MULTITHREADED);
HBITMAP hResult = 0;
if (SUCCEEDED(CoCreateInstance (CLSID_ImagingFactory,
NULL,
CLSCTX_INPROC_SERVER,
IID_IImagingFactory,
(void **)&pImgFactory)))
{
ImageInfo imageInfo;
if (SUCCEEDED(pImgFactory->CreateImageFromFile(CA2W(strFileName.c_str()), &pImage))
&& SUCCEEDED(pImage->GetImageInfo(&imageInfo)))
{
CWindowDC dc(getMainWnd());
CDC dcBitmap;
dcBitmap.CreateCompatibleDC(dc.m_hDC);
hResult = CreateCompatibleBitmap(dc.m_hDC, imageInfo.Width, imageInfo.Height);
if (hResult)
{
HBITMAP hOldBitmap = dcBitmap.SelectBitmap(hResult);
//dcBitmap.FillSolidRect( 0,0, imageInfo.Width, imageInfo.Height, RGB(255,255,255));
CRect rc(0, 0, imageInfo.Width, imageInfo.Height);
COLORREF clrOld = ::SetBkColor(dcBitmap.m_hDC, RGB(255,255,255));
::ExtTextOut(dcBitmap.m_hDC, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
::SetBkColor(dcBitmap.m_hDC, clrOld);
pImage->Draw(dcBitmap.m_hDC, rc, NULL);
dcBitmap.SelectBitmap(hOldBitmap);
}
pImage->Release();
}
pImgFactory->Release();
}
//CoUninitialize();
return hResult;
}
void CAnimImage::init()
{
anim->load(frame, group);
if (flags & CShowableAnim::BASE)
anim->load(0,group);
IImage *img = anim->getImage(frame, group);
if (img)
{
pos.w = img->width();
pos.h = img->height();
}
}
ITexture* createRainbowTexture( IVideoDriver* driver, u32 w, u32 h, u8 transparency, f64 gamma)
{
if (!driver)
{
return 0;
}
IImage* img = createRainbowImage(w,h,transparency, gamma);
if (!img)
return 0;
ITexture* tex = 0;
//! save states
bool b0 = driver->getTextureCreationFlag(ETCF_ALLOW_NON_POWER_2);
bool b1 = driver->getTextureCreationFlag(ETCF_ALWAYS_16_BIT);
bool b2 = driver->getTextureCreationFlag(ETCF_ALWAYS_32_BIT);
bool b3 = driver->getTextureCreationFlag(ETCF_CREATE_MIP_MAPS);
bool b4 = driver->getTextureCreationFlag(ETCF_FORCE_32_BIT_DO_NOT_USE);
bool b5 = driver->getTextureCreationFlag(ETCF_NO_ALPHA_CHANNEL);
bool b6 = driver->getTextureCreationFlag(ETCF_OPTIMIZED_FOR_QUALITY);
bool b7 = driver->getTextureCreationFlag(ETCF_OPTIMIZED_FOR_SPEED);
//! my states
driver->setTextureCreationFlag(ETCF_ALLOW_NON_POWER_2,true);
driver->setTextureCreationFlag(ETCF_ALWAYS_16_BIT,false);
driver->setTextureCreationFlag(ETCF_ALWAYS_32_BIT,true);
driver->setTextureCreationFlag(ETCF_CREATE_MIP_MAPS,true);
driver->setTextureCreationFlag(ETCF_FORCE_32_BIT_DO_NOT_USE,false);
driver->setTextureCreationFlag(ETCF_NO_ALPHA_CHANNEL,false);
driver->setTextureCreationFlag(ETCF_OPTIMIZED_FOR_QUALITY,true);
driver->setTextureCreationFlag(ETCF_OPTIMIZED_FOR_SPEED,false);
//! my RainbowTexture
tex = driver->addTexture("rainbow", img, 0);
//! restore states
driver->setTextureCreationFlag(ETCF_ALLOW_NON_POWER_2,b0);
driver->setTextureCreationFlag(ETCF_ALWAYS_16_BIT,b1);
driver->setTextureCreationFlag(ETCF_ALWAYS_32_BIT,b2);
driver->setTextureCreationFlag(ETCF_CREATE_MIP_MAPS,b3);
driver->setTextureCreationFlag(ETCF_FORCE_32_BIT_DO_NOT_USE,b4);
driver->setTextureCreationFlag(ETCF_NO_ALPHA_CHANNEL,b5);
driver->setTextureCreationFlag(ETCF_OPTIMIZED_FOR_QUALITY,b6);
driver->setTextureCreationFlag(ETCF_OPTIMIZED_FOR_SPEED,b7);
img->drop(); // delete rainbow-image
return tex;
} // END FUNCTION
//-----------------------------------------------------------------------------
// Purpose: Draw the current image
//-----------------------------------------------------------------------------
void AnimatingImagePanel::PaintBackground()
{
if ( m_Frames.IsValidIndex( m_iCurrentImage ) && m_Frames[m_iCurrentImage] != NULL )
{
IImage *pImage = m_Frames[m_iCurrentImage];
surface()->DrawSetColor( 255, 255, 255, 255 );
pImage->SetPos(0, 0);
if ( m_bScaleImage )
{
// Image size is stored in the bitmap, so temporarily set its size
// to our panel size and then restore after we draw it.
int imageWide, imageTall;
pImage->GetSize( imageWide, imageTall );
int wide, tall;
GetSize( wide, tall );
pImage->SetSize( wide, tall );
pImage->SetColor( Color( 255,255,255,255 ) );
pImage->Paint();
pImage->SetSize( imageWide, imageTall );
}
else
{
pImage->Paint();
}
}
}
bool CAnimation::loadFrame(CDefFile * file, size_t frame, size_t group)
{
if (size(group) <= frame)
{
printError(frame, group, "LoadFrame");
return false;
}
IImage *image = getImage(frame, group, false);
if (image)
{
image->increaseRef();
return true;
}
//try to get image from def
if (source[group][frame].getType() == JsonNode::DATA_NULL)
{
if (file)
{
auto frameList = file->getEntries();
if (vstd::contains(frameList, group) && frameList.at(group) > frame) // frame is present
{
if (compressed)
images[group][frame] = new CompImage(file, frame, group);
else
images[group][frame] = new SDLImage(file, frame, group);
return true;
}
}
// still here? image is missing
printError(frame, group, "LoadFrame");
images[group][frame] = new SDLImage("DEFAULT", compressed);
}
else //load from separate file
{
std::string filename = source[group][frame].Struct().find("file")->second.String();
IImage * img = getFromExtraDef(filename);
if (!img)
img = new SDLImage(filename, compressed);
images[group][frame] = img;
return true;
}
return false;
}
//! opens the file and loads it into the surface
ITexture* CNullDriver::loadTextureFromFile(IReadFile* file, const path& hashName )
{
ITexture* texture = 0;
IImage* image = createImageFromFile(file);
if (image)
{
// create texture from surface
texture = createDeviceDependentTexture(image, hashName.size() ? hashName : file->getFileName() );
Printer::log("Loaded texture", file->getFileName());
image->releaseRef();
}
return texture;
}
