int main(int argc, char **argv)
{
ILuint ImgId;
ILenum Error;
char *Data;
long Size;
// We use the filename specified in the first argument of the command-line.
if (argc < 3) {
printf("Please specify a .rar file and file inside to open.\n");
return 1;
}
// Check if the shared lib's version matches the executable's version.
if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION ||
iluGetInteger(ILU_VERSION_NUM) < ILU_VERSION) {
printf("DevIL version is different...exiting!\n");
return 2;
}
// Initialize DevIL.
ilInit();
// Generate the main image name to use.
ilGenImages(1, &ImgId);
// Bind this image name.
ilBindImage(ImgId);
if (!urarlib_get(&Data, &Size, argv[2], argv[1], "none")) {
printf("Error loading .rar file.\n");
return 3;
}
// Loads the image specified by File into the image named by ImgId.
ilLoadL(IL_TGA, Data, Size);
// Display the image's dimensions to the end user.
printf("Width: %d Height: %d Depth: %d Bpp: %d\n", ilGetInteger(IL_IMAGE_WIDTH),
ilGetInteger(IL_IMAGE_HEIGHT), ilGetInteger(IL_IMAGE_DEPTH), ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL));
// Enable this to let us overwrite the destination file if it already exists.
ilEnable(IL_FILE_OVERWRITE);
// If argv[2] is present, we save to this filename, else we save to test.tga.
if (argc > 2)
ilSaveImage(argv[3]);
else
ilSaveImage("test.tga");
// We're done with the image, so let's delete it.
ilDeleteImages(1, &ImgId);
// Simple Error detection loop that displays the Error to the user in a human-readable form.
while ((Error = ilGetError())) {
printf("Error: %s\n", iluErrorString(Error));
}
return 0;
}
void CDevILCodec::CodeToFile(const nstring & filename, const CImage &image)
{
ILuint imageid;
CDevILFormats informat;
informat.SetExFormat(image.GetPixelFormat());
// Generate the main image name to use.
ilGenImages(1, &imageid);
// Bind this image name.
ilBindImage(imageid);
ilTexImage(image.GetWidth(), image.GetHeight(), image.GetDepth(), informat.GetInternalChannels(),
informat.GetFormat(), IL_UNSIGNED_BYTE, image.GetBitsPtr());
ilSaveImage(filename.c_str());
ilDeleteImages(1, &imageid);
ILenum Error = 0;
if((Error = ilGetError()) != NULL)
{
nstring str("CDevILCodec::CodeToFile: ");
str.append(iluErrorString(Error));
throw NOVA_EXP(str.c_str(), BAD_OPERATION);
}
}
static void captureImage(void) {
// capture
//ILuint ratz;
//vector<GLubyte> store;
char *savePath[200];
//GLubyte *store= GLubyte[xsize * ysize * 4];
GLubyte store[307200];
/* capture */
//ilGenImages(1, &ratz);
//ilBindImage(ratz);
//store.resize(xsize * ysize * 4);
glReadPixels(0, 0, xsize, ysize, GL_RGBA, GL_UNSIGNED_BYTE, &store[0]);
//glReadPixels(0, 0, 240, 320, GL_RGBA, GL_UNSIGNED_BYTE, &store[0]);
ilTexImage(xsize, ysize, 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, &store[0]);
ilEnable(IL_FILE_OVERWRITE);
//ilSaveImage(sortie.c_str());
strcpy(savePath, outputDir);
strcat(savePath, filename);
//ilSaveImage("C:\\Documents and Settings\\Administrator\\Desktop\\carpark - AR\\out.jpg");
printf("Saving %s\n", savePath);
ilSaveImage(savePath);
//ilSaveImage("C:\\Documents and Settings\\Administrator\\Desktop\\carpark - AR\\output\\out.jpg");
/* capture */
}
bool nTextureManager::saveTexture(nTexture *tex, string name) {
if(!glIsTexture(tex->tex)) {
return false;
}
mutex->lock();
unsigned char *dat = new unsigned char[3 * (unsigned int)(tex->size.x * tex->size.y)];
glBindTexture(GL_TEXTURE_2D, tex->tex);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, dat);
ILuint img;
ilGenImages(1, &img);
ilBindImage(img);
iluScale(tex->size.x, tex->size.y, 1);
ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);
bool t = ilTexImage(tex->size.x, tex->size.y, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, dat);
ILuint error = ilGetError();
GLuint glError = glGetError();
if(error || !t || glError) {
nGine::instance()->getLogger()->addDebugLog("Error while saving file : " + nLogger::numToString((int)error) + "/" + nLogger::numToString((int)glError));
mutex->unlock();
return false;
}
bool a = ilSaveImage((nGine::instance()->appPath() + name).c_str());
mutex->unlock();
return a;
}
void CBitmap::Save(string const& filename)
{
ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
ilEnable(IL_ORIGIN_SET);
unsigned char* buf=new unsigned char[xsize*ysize*4];
/* HACK Flip the image so it saves the right way up.
(Fiddling with ilOriginFunc didn't do anything?)
Duplicated with ReverseYAxis. */
for(int y=0;y<ysize;++y){
for(int x=0;x<xsize;++x){
buf[((ysize-1-y)*xsize+x)*4+0]=mem[((y)*xsize+x)*4+0];
buf[((ysize-1-y)*xsize+x)*4+1]=mem[((y)*xsize+x)*4+1];
buf[((ysize-1-y)*xsize+x)*4+2]=mem[((y)*xsize+x)*4+2];
buf[((ysize-1-y)*xsize+x)*4+3]=mem[((y)*xsize+x)*4+3];
}
}
ilHint(IL_COMPRESSION_HINT, IL_USE_COMPRESSION);
ilSetInteger (IL_JPG_QUALITY, 80);
ILuint ImageName = 0;
ilGenImages(1, &ImageName);
ilBindImage(ImageName);
ilTexImage(xsize,ysize,1,4,IL_RGBA,IL_UNSIGNED_BYTE,NULL);
ilSetData(buf);
ilSaveImage((char*)filename.c_str());
ilDeleteImages(1,&ImageName);
delete[] buf;
}
void CMainDlg::ExportTextures(const CString &path)
{
ILuint handle;
ilInit();
iluInit();
ilOriginFunc(IL_ORIGIN_LOWER_LEFT);
ilEnable(IL_ORIGIN_SET);
for(int i = 0; i < m_Textures.GetCount(); i++)
{
if(texdata[i] != -1)
{
ilGenImages(1, & handle);
ilBindImage(handle);
CString file;
m_Textures.GetText(i, file);
vector<char> data;
data.resize(sc.index[texdata[i]].fileSize);
ifstream is;
is.sync_with_stdio(false);
is.open(sc.index[texdata[i]].cachename.c_str(), ios::binary|ios::in);
is.read(reinterpret_cast<char*>(&data[0]), sc.index[texdata[i]].fileSize);
is.close();
ILboolean ret = ilLoadL(IL_DDS, reinterpret_cast<char*>(&data[0]), sc.index[texdata[i]].fileSize);
file.Replace(".dds", ".png");
iluFlipImage();
ilSaveImage((path + file));
/*ofstream out;
out.sync_with_stdio(false);
out.open(path + file, ios::binary);
out.write(reinterpret_cast<char*>(&data[0]), sc.index[texdata[i]].fileSize);
out.close();*/
ilDeleteImages(1, & handle);
}
}
}
//---------------------------------------------------------------------
void ILImageCodec::codeToFile(MemoryDataStreamPtr& input,
const String& outFileName, Codec::CodecDataPtr& pData) const
{
ILuint ImageName;
ilGenImages( 1, &ImageName );
ilBindImage( ImageName );
ImageData* pImgData = static_cast< ImageData * >( pData.getPointer() );
PixelBox src(pImgData->width, pImgData->height, pImgData->depth, pImgData->format, input->getPtr());
// Convert image from OGRE to current IL image
ILUtil::fromOgre(src);
iluFlipImage();
// Implicitly pick DevIL codec
ilSaveImage(const_cast< char * >( outFileName.c_str() ) );
// Check if everything was ok
ILenum PossibleError = ilGetError() ;
if( PossibleError != IL_NO_ERROR ) {
ilDeleteImages(1, &ImageName);
OGRE_EXCEPT( Exception::ERR_NOT_IMPLEMENTED,
"IL Error, could not save file: " + outFileName,
iluErrorString(PossibleError) ) ;
}
ilDeleteImages(1, &ImageName);
}
// ページを書き出す
void dumpPage ( Page *_page, const char *_name ) {
// 画像出力はDevIL任せ
ilTexImage ( PAGE_SIZE_X * 6, PAGE_SIZE_Y * 8, 1, 1, IL_LUMINANCE, IL_UNSIGNED_BYTE, ( void* ) ( _page->buffer ) );
char filename[ MAX_FILENAME_LENGTH ];
snprintf ( filename, 256, "%s_%02d.png", _name, _page->current_page );
ilSaveImage ( filename );
}
void ImageSequenceSave::saveImage(const std::string& filename, tgt::Texture* image) throw (VoreenException) {
tgtAssert(filename != "", "filename is empty");
tgtAssert(tgt::FileSystem::fileExtension(filename) != "", "filename has no extension");
tgtAssert(image, "no texture");
if (image->getDepth() > 1)
throw VoreenException("Passed image is a 3D texture");
// get color buffer content
tgt::ivec2 dim = image->getDimensions().xy();
bool luminance = (image->getFormat() == GL_LUMINANCE);
GLushort* colorBuffer;
if (luminance)
colorBuffer = reinterpret_cast<GLushort*>(image->downloadTextureToBuffer(GL_LUMINANCE, GL_UNSIGNED_SHORT));
else
colorBuffer = reinterpret_cast<GLushort*>(image->downloadTextureToBuffer(GL_RGBA, GL_UNSIGNED_SHORT));
// create Devil image from image data and write it to file
ILuint img;
ilGenImages(1, &img);
ilBindImage(img);
// put pixels into IL-Image
ilTexImage(dim.x, dim.y, 1, (luminance ? 1 : 4), (luminance ? IL_LUMINANCE : IL_RGBA), IL_UNSIGNED_SHORT, colorBuffer);
ilEnable(IL_FILE_OVERWRITE);
ilResetWrite();
ILboolean success = ilSaveImage(const_cast<char*>(filename.c_str()));
ilDeleteImages(1, &img);
delete[] colorBuffer;
if (!success) {
throw VoreenException(DevILModule::getDevILError());
}
}
// Image saver...
bit DevilSave(cstrconst filename,nat32 width,nat32 height,nat32 format,nat32 type,void * data,bit overwrite)
{
unsigned int handle;
ilGenImages(1,(unsigned int *)&handle);
ilBindImage(handle);
ilEnable(0x0600);
ilOriginFunc(0x0601);
if (overwrite) ilEnable(DEVIL_FILE_SQUISH);
else ilDisable(DEVIL_FILE_SQUISH);
int num;
switch (format)
{
case DEVIL_FORM_RGB: num = 3; break;
case DEVIL_FORM_RGBA: num = 4; break;
default: num = 1; break;
}
ilTexImage(width,height,1,num,format,type,data);
ilSaveImage(filename);
if (ilGetError())
{
ilDeleteImages(1,(unsigned int *)&handle);
return false;
}
else
{
ilDeleteImages(1,(unsigned int *)&handle);
return true;
}
}
void Image::save_to_file(const string& filename)
{
if (!devil_initialized) {
ilInit();
devil_initialized = true;
}
ILuint il_image;
ilGenImages(1, &il_image);
ilTexImage(_width, _height, 0, _bpp, _format, _type, _data);
ILboolean success = ilSaveImage(filename.c_str());
if (!success) {
cerr << "Image::Image "
<< "Failed to save to image file "
<< filename << endl;
_data = NULL;
return;
}
ilBindImage(0);
ilDeleteImages(1, &il_image);
}
bool M_saveImage(const char * filename, void * data, unsigned int quality)
{
DevILInit();
ILuint ImgId = 0;
ilGenImages(1, &ImgId);
// bind this image name.
ilBindImage(ImgId);
MImage * image = (MImage *)data;
unsigned int width = image->getWidth();
unsigned int height = image->getHeight();
unsigned int components = image->getComponents();
if(components == 3)
ilTexImage(width, height, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, image->getData());
else if(components == 4)
ilTexImage(width, height, 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, image->getData());
iluFlipImage();
if(quality < 100)
ilSetInteger(IL_JPG_QUALITY, quality);
ilEnable(IL_FILE_OVERWRITE);
ilSaveImage(filename);
ilDeleteImages(1, &ImgId);
DevILShutDown();
return true;
}
void
SaveTextureToImageFile( uint32 aWidth, uint32 aHeight, GLuint aTexture, std::string aPath, bool aOverwrite )
{
//TODO auto_ptr on textures
ILuint imageID; // The image name to return.
DEVIL_CHECKED_CALL( ilGenImages( 1, &imageID ) );
DEVIL_CHECKED_CALL( ilBindImage( imageID ) );
if ( aOverwrite ) {
DEVIL_CHECKED_CALL( ilEnable(IL_FILE_OVERWRITE) );
} else {
DEVIL_CHECKED_CALL( ilDisable(IL_FILE_OVERWRITE) );
}
DEVIL_CHECKED_CALL( ilTexImage( aWidth, aHeight, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL ) );
ILubyte* data = new ILubyte[ 3 * aWidth * aHeight ];
GL_CHECKED_CALL( glBindTexture( GL_TEXTURE_2D, aTexture ) );
GL_CHECKED_CALL( glGetTexImage(
GL_TEXTURE_2D,
0,
GL_RGB,
GL_UNSIGNED_BYTE,
(void*)data
) );
GL_CHECKED_CALL( glBindTexture( GL_TEXTURE_2D, 0 ) );
DEVIL_CHECKED_CALL( ilSetPixels( 0, 0, 0, aWidth, aHeight, 1, IL_RGB, IL_UNSIGNED_BYTE, data ) );
delete [] data;
DEVIL_CHECKED_CALL( ilSaveImage( aPath.data() ) );
DEVIL_CHECKED_CALL( ilDeleteImages( 1, &imageID) );
}
void test_ilLoad(wchar_t* sourceFN, wchar_t* targetFN)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
//printf("Loading " PathCharMod "\n", sourceFN);
ilResetRead();
ILenum sourceType = ilDetermineType(sourceFN);
if (!ilLoad(sourceType, sourceFN)) {
printf("test_ilLoad: Failed to load %S\n", sourceFN);
++errors;
return;
}
testHeap();
//ilConvertImage(IL_BGR, IL_UNSIGNED_BYTE);
//ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
//iluScale(150, 150, 1);
testHeap();
DeleteFile(targetFN);
//printf("Saving " PathCharMod "\n", targetFN);
if (!ilSaveImage(targetFN)) {
printf("test_ilLoad: Failed to save " PathCharMod "\n", targetFN);
++errors;
}
testHeap();
ilDeleteImage(handle);
}
int main(const int argc, const char* const argv[]) {
param_t parameters;
if(!parse_args(argc, argv, ¶meters)) {
return EXIT_FAILURE;
}
ilInit();
ilEnable(IL_ORIGIN_SET);
ilOriginFunc(IL_ORIGIN_LOWER_LEFT);
ILuint image;
ilGenImages(1, &image);
ilBindImage(image);
const ILboolean load_success = ilLoadImage(parameters.in);
if(load_success== IL_FALSE) {
// handle error TODO
ilDeleteImages(1, &image);
return EXIT_FAILURE;
}
const ILboolean convert_success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);
if(convert_success == IL_FALSE) {
// handle error TODO
ilDeleteImages(1, &image);
return EXIT_FAILURE;
}
const ILint width = ilGetInteger(IL_IMAGE_WIDTH);
const ILint height = ilGetInteger(IL_IMAGE_HEIGHT);
const ILint out_width = width / parameters.scale;
const ILint out_height = height / parameters.scale;
ILubyte out_data[out_width * out_height];
const image_t in = {
.width = width,
.height = height,
.data = ilGetData(),
};
const image_t out = {
.width = out_width,
.height = out_height,
.data = out_data,
};
convert(in, out, parameters);
ilDeleteImages(1, &image);
ILuint out_image;
ilGenImages(1, &out_image);
ilBindImage(out_image);
ilTexImage(out_width, out_height, 1, 1, IL_LUMINANCE, IL_UNSIGNED_BYTE, &out_data);
ilEnable(IL_FILE_OVERWRITE);
ilSaveImage(parameters.out);
ilDeleteImages(1, &image);
return EXIT_SUCCESS;
}
void test_ilLoadFuncs(wchar_t* sourceFN, wchar_t* targetFN)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
//printf("Loading " PathCharMod "\n", sourceFN);
FILE* f = _wfopen(sourceFN, L"rb");
bool loaded = false;
if (f != NULL) {
fseek(f, 0, SEEK_END);
myDataSize = ftell(f);
if (myDataSize > 0) {
fseek(f, 0, SEEK_SET);
myData = new BYTE[myDataSize];
size_t read = fread(myData, 1, myDataSize, f);
myReadPos = 0;
if (read == myDataSize) {
//loaded = ilLoadL(IL_TYPE_UNKNOWN, lump, read);
ilSetRead(myOpenProc, myCloseProc, myEofProc, myGetcProc, myReadProc, mySeekProc, myTellProc);
loaded = ilLoadFuncs(IL_TYPE_UNKNOWN);
if (!loaded) {
printf("test_ilLoadFuncs: Failed to load " PathCharMod "\n", sourceFN);
++errors;
}
} else {
printf("test_ilLoadFuncs: Failed to read " PathCharMod "\n", sourceFN);
++errors;
}
delete myData;
}
fclose(f);
} else {
printf("test_ilLoadFuncs: Failed to open %S\n", sourceFN);
++errors;
}
testHeap();
//ilConvertImage(IL_BGR, IL_UNSIGNED_BYTE);
//ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
//iluScale(150, 150, 1);
testHeap();
DeleteFile(targetFN);
//printf("Saving " PathCharMod "\n", targetFN);
if (loaded)
if(!ilSaveImage(targetFN)) {
printf("Failed to save " PathCharMod " after ilLoadFuncs\n", targetFN);
++errors;
}
testHeap();
ilDeleteImage(handle);
}
void ilFSaveImage_(int *RetVal, struct descriptor *Desc)
{
char *Filename = malloc(Desc->length + 1);
strncpy(Filename, Desc->string_ptr, Desc->length);
Filename[Desc->length] = 0; // Should really be NULL...getting a warning, though.
*RetVal = ilSaveImage(Filename);
free(Filename);
return;
}
void test_ilLoadL(wchar_t* sourceFN, wchar_t* targetFN)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
//printf("Loading " PathCharMod "\n", sourceFN);
FILE* f = _wfopen(sourceFN, L"rb");
bool loaded = false;
if (f != NULL) {
fseek(f, 0, SEEK_END);
INT64 size = ftell(f);
if (size > 0) {
fseek(f, 0, SEEK_SET);
char* lump = new char[size];
size_t read = fread(lump, 1, size, f);
if (read == size) {
loaded = ilLoadL(IL_TYPE_UNKNOWN, lump, read);
if (!loaded) {
printf("test_ilLoadL: Failed to load " PathCharMod "\n", sourceFN);
++errors;
}
} else {
printf("test_ilLoadL: Failed to read " PathCharMod "\n", sourceFN);
++errors;
}
delete lump;
}
fclose(f);
} else {
printf("test_ilLoadL: Failed to load %S\n", sourceFN);
++errors;
}
testHeap();
//ilConvertImage(IL_BGR, IL_UNSIGNED_BYTE);
//ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
//iluScale(150, 150, 1);
testHeap();
DeleteFile(targetFN);
//printf("Saving " PathCharMod "\n", targetFN);
if (loaded)
if (!ilSaveImage(targetFN)) {
printf("test_ilLoadL: Failed to save " PathCharMod "\n", targetFN);
++errors;
}
testHeap();
ilDeleteImage(handle);
}
void Texture::SaveAs(std::string pszFileName, size_t piWidth, size_t piHeight, size_t pType, size_t pFmt, void * pData)
{
ILuint _iImageId = 0;
_iImageId = ilGenImage();
ilBindImage(_iImageId);
ASSERT( ilTexImage(piWidth, piHeight, 0, 3, pType, pFmt, pData) == IL_TRUE , "Texture: Unable to set data!");
VERIFY( ilSaveImage(pszFileName.c_str()) == IL_TRUE , "Texture: Unable to save Image!");
ilDeleteImage(_iImageId);
}
bool DrawAbstract::save(std::string path){
unsigned char *data = new unsigned char[4*screen_width*screen_height];
glReadBuffer(GL_BACK);
glReadPixels(0,0,screen_width,screen_height,GL_RGBA, GL_UNSIGNED_BYTE,data);
ilTexImage(screen_width,screen_height,1,4,IL_RGBA, IL_UNSIGNED_BYTE,data);
ilEnable(IL_FILE_OVERWRITE);
ilSaveImage(path.c_str());
delete data;
return true;
}
void Renderer::saveScreenshot(const std::string& filename, int width, int height)
{
ILuint tex;
tex = IL_CHECK(ilGenImage());
IL_CHECK(ilBindImage(tex));
void* data = malloc(width * height * 3);
glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, data);
ilTexImage(width, height, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, data);
free(data);
IL_CHECK(ilSaveImage(filename.c_str()));
IL_CHECK(ilDeleteImage(tex));
}
// methods
void Texture::Save(const char* filename)
{
uint handle = 0;
ilGenImages(1, &handle);
ilBindImage(handle);
ilTexImage(width, height, 0, channels, format, IL_FLOAT, data);
ilConvertImage(format, IL_UNSIGNED_BYTE);
ilSaveImage(filename);
ilDeleteImage(handle);
ilBindImage(0);
}
void takeScreenShot(const string prefix) {
ILuint handle=0;
ilGenImages(1, &handle);
ilBindImage(handle);
ilutGLScreen();
createDirectory(FileName("sshots/"));
char *pszScreenShotFileName = strdup(getScreenShotFileName(prefix).str());
ilSaveImage(pszScreenShotFileName);
delete[] pszScreenShotFileName;
ilDeleteImages(1, &handle);
}
void plot_saveimage(const char* name){
ILubyte *data = ilGetData();
int viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
int x = viewport[0];
int y = viewport[1];
int width = viewport[2];
int height = viewport[3];
glReadPixels(x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, data);
ilEnable(IL_FILE_OVERWRITE);
ilSaveImage(name);
}
bool CBitmap::Save(std::string const& filename, bool opaque) const
{
if (type == BitmapTypeDDS) {
#ifndef BITMAP_NO_OPENGL
return ddsimage->save(filename);
#else
return false;
#endif // !BITMAP_NO_OPENGL
}
unsigned char* buf = new unsigned char[xsize * ysize * 4];
const int ymax = (ysize - 1);
/* HACK Flip the image so it saves the right way up.
(Fiddling with ilOriginFunc didn't do anything?)
Duplicated with ReverseYAxis. */
for (int y = 0; y < ysize; ++y) {
for (int x = 0; x < xsize; ++x) {
const int bi = 4 * (x + (xsize * (ymax - y)));
const int mi = 4 * (x + (xsize * (y)));
buf[bi + 0] = mem[mi + 0];
buf[bi + 1] = mem[mi + 1];
buf[bi + 2] = mem[mi + 2];
buf[bi + 3] = opaque ? 0xff : mem[mi + 3];
}
}
boost::mutex::scoped_lock lck(devilMutex);
ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
ilEnable(IL_ORIGIN_SET);
ilHint(IL_COMPRESSION_HINT, IL_USE_COMPRESSION);
ilSetInteger(IL_JPG_QUALITY, 80);
ILuint ImageName = 0;
ilGenImages(1, &ImageName);
ilBindImage(ImageName);
ilTexImage(xsize, ysize, 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, buf);
const std::string fullpath = dataDirsAccess.LocateFile(filename, FileQueryFlags::WRITE);
const bool success = ilSaveImage((char*)fullpath.c_str());
ilDeleteImages(1, &ImageName);
ilDisable(IL_ORIGIN_SET);
delete[] buf;
return success;
}
int main(int argc, char* argv[]) {
if (argc != 3) {
printf("Usage: %s <input data file> <output image file>", argv[0]);
}
byte* img = malloc(IMG_ARRAY_LENGTH);
ilInit();
uint pos = 0;
FILE* dataFile = fopen(argv[1], "r");
while (fscanf(dataFile, "%2hhx", &(img[pos++])) == 1) { }
fclose(dataFile);
ilTexImage(IMG_WIDTH, IMG_HEIGHT, 0, 3, IL_RGB, IL_UNSIGNED_BYTE, img);
ilSaveImage(argv[2]);
}
void test_ilLoadF(wchar_t* sourceFN, wchar_t* targetFN)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
//printf("Loading " PathCharMod "\n", sourceFN);
bool loaded = false;
//FILE* f = _wfopen(sourceFN, L"rb");
FILE * f;
char buf[10];
_wfopen_s(&f, sourceFN, L"rb");
fread(buf, 1, 10, f);
fseek(f, 0, IL_SEEK_SET);
if (f != NULL) {
loaded = ilLoadF(IL_TYPE_UNKNOWN, f);
if(!loaded) {
printf("test_ilLoadF: Failed to load %S\n", sourceFN);
++errors;
}
} else {
printf("test_ilLoadF: Failed to open %S\n", sourceFN);
++errors;
}
fclose(f);
testHeap();
//ilConvertImage(IL_BGR, IL_UNSIGNED_BYTE);
//ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
//iluScale(150, 150, 1);
testHeap();
DeleteFile(targetFN);
//printf("Saving " PathCharMod "\n", targetFN);
if (loaded)
if (!ilSaveImage(targetFN)) {
printf ("test_ilLoadF: Failed to save %S\n", targetFN);
++errors;
}
testHeap();
ilDeleteImage(handle);
}
bool ImageLoader::saveImageRGBA(const char* image, u8* data, u32 width, u32 height)
{
ILuint handle;
// In the next section, we load one image
ilGenImages(1, &handle);
ilBindImage(handle);
ilTexImage(width, height, 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, data);
ilEnable(IL_FILE_OVERWRITE);
const ILboolean saved = ilSaveImage(image);
// Finally, clean the mess!
ilDeleteImages(1, &handle);
return saved ? true : false;
}
int do_stuff(const Params * parameters)
{
if (parameters->Flags & FLAG_HELP || ((parameters->Flags | FLAG_LOAD | FLAG_SAVE) != parameters->Flags) )
{/* We wanted HELP or we did not get SAVE or LOAD */
print_help(); /* tell the loser what to do, then :-) */
return 0;
}
int verbose = parameters->Flags & FLAG_VERBOSE;
int image_handle;
int w, h;
ILboolean result;
/* Quite obvious stuff, just load an image */
ilGenImages(1, & image_handle);
ilBindImage(image_handle);
result = ilLoadImage(parameters->Load_filename);
if (result == IL_FALSE)
{
int error = ilGetError();
fprintf(stderr, "Error: Something went wrong when loading file '%s' (%s)\n", parameters->Load_filename, iluErrorString(error));
return error;
}
/* If we get image's dimensions, people will believe that we have actually loaded something :-) */
w = ilGetInteger(IL_IMAGE_WIDTH);
h = ilGetInteger(IL_IMAGE_HEIGHT);
if (verbose)
printf("Loaded '%s', size %dx%d\n", parameters->Load_filename, w, h);
/* Now let's do our stuff!!! */
int i;
for (i = 0; i < parameters->Calls_count; i++)
perform_operation(parameters->Calls_strings[i], verbose);
/* our stuff has been done... */
result = ilSaveImage(parameters->Save_filename);
if (result == IL_FALSE)
{
int error = ilGetError();
fprintf(stderr, "Error: Something went wrong when saving file '%s' (%s)\n", parameters->Save_filename, iluErrorString(error));
ilDeleteImages(1, & image_handle);
return error;
}
ilDeleteImages(1, & image_handle);
return 0;
}
void SaveImage(const char *fn, int components, GLenum type, int w,int h, void *data)
{
// We use the fact that DevIL has the same constants for component type as OpenGL
/// ( GL_UNSIGNED_BYTE = IL_UNSIGNED_BYTE for example )
#ifdef TERRAIN_USE_IL
// Save image
ILuint out;
ilGenImages(1,&out);
ilBindImage(out);
ILenum fmt=IL_RGB;
if (components==4) fmt = IL_RGBA;
if (components==1) fmt = IL_LUMINANCE;
ilTexImage(w,h,1,components,fmt,type,data);
filesystem.Remove(fn);
ilSaveImage((ILstring)fn);
ilDeleteImages(1,&out);
#endif
}
