//! Writes a Pnm file ILboolean ilSavePnm(const ILstring FileName) { ILHANDLE PnmFile; ILboolean bPnm = IL_FALSE; FName = (ILstring)FileName; if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } PnmFile = iopenw(FileName); if (PnmFile == NULL) { ilSetError(IL_COULD_NOT_OPEN_FILE); return bPnm; } bPnm = ilSavePnmF(PnmFile); iclosew(PnmFile); return bPnm; }
//! Writes a Jpeg file ILboolean ilSave_JPEG(const ILstring FileName) { ILHANDLE JpegFile; ILuint JpegSize; if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } JpegFile = iopenw(FileName); if (JpegFile == NULL) { ilSetError(IL_COULD_NOT_OPEN_FILE); return IL_FALSE; } JpegSize = ilSaveF_JPEG(JpegFile); iclosew(JpegFile); if (JpegSize == 0) return IL_FALSE; return IL_TRUE; }
//! Writes a Jpeg file ILboolean ilSave_JPEG(ILconst_string FileName) { if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } return iSaveJpegInternal(FileName, NULL, 0); }
// Basically just ireads 4096 bytes and copies the palette ILboolean iLoadDoomFlatInternal() { ILubyte *NewData; ILuint i; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } if (!ilTexImage(64, 64, 1, 1, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NULL)) { return IL_FALSE; } iCurImage->Origin = IL_ORIGIN_UPPER_LEFT; iCurImage->Pal.Palette = (ILubyte*)ialloc(IL_DOOMPAL_SIZE); if (iCurImage->Pal.Palette == NULL) { return IL_FALSE; } iCurImage->Pal.PalSize = IL_DOOMPAL_SIZE; iCurImage->Pal.PalType = IL_PAL_RGB24; memcpy(iCurImage->Pal.Palette, ilDefaultDoomPal, IL_DOOMPAL_SIZE); if (iread(iCurImage->Data, 1, 4096) != 4096) return IL_FALSE; if (ilGetBoolean(IL_CONV_PAL) == IL_TRUE) { NewData = (ILubyte*)ialloc(iCurImage->SizeOfData * 4); if (NewData == NULL) { return IL_FALSE; } for (i = 0; i < iCurImage->SizeOfData; i++) { NewData[i * 4] = iCurImage->Pal.Palette[iCurImage->Data[i]]; NewData[i * 4] = iCurImage->Pal.Palette[iCurImage->Data[i]]; NewData[i * 4] = iCurImage->Pal.Palette[iCurImage->Data[i]]; NewData[i * 4 + 3] = iCurImage->Data[i] != 247 ? 255 : 0; } if (!ilTexImage(iCurImage->Width, iCurImage->Height, iCurImage->Depth, 4, IL_RGBA, iCurImage->Type, NewData)) { ifree(NewData); return IL_FALSE; } iCurImage->Origin = IL_ORIGIN_UPPER_LEFT; ifree(NewData); } ilFixImage(); return IL_TRUE; }
ILboolean ilSaveJpeg(ILconst_string FileName) { ILHANDLE JpegFile; ILboolean bJpeg = IL_FALSE; if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } JpegFile = iopenw(FileName); if (JpegFile == NULL) { ilSetError(IL_COULD_NOT_OPEN_FILE); return bJpeg; } bJpeg = ilSaveJpegF(JpegFile); iclosew(JpegFile); return bJpeg; }
//! Writes a Hdr file ILboolean ilSaveHdr(ILconst_string FileName) { ILHANDLE HdrFile; ILboolean bHdr = IL_FALSE; if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } HdrFile = iopenw(FileName); if (HdrFile == NULL) { ilSetError(IL_COULD_NOT_OPEN_FILE); return bHdr; } bHdr = ilSaveHdrF(HdrFile); iclosew(HdrFile); return bHdr; }
ILboolean ilSaveRaw(const ILstring FileName) { ILHANDLE RawFile; ILboolean bRaw = IL_FALSE; if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } RawFile = iopenw(FileName); if (RawFile == NULL) { ilSetError(IL_COULD_NOT_OPEN_FILE); return bRaw; } bRaw = ilSaveRawF(RawFile); iclosew(RawFile); return bRaw; }
//! Writes a Tiff file ILboolean ilSaveTiff(const ILstring FileName) { ILHANDLE TiffFile; ILboolean bTiff = IL_FALSE; if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } TiffFile = iopenw(FileName); if (TiffFile == NULL) { ilSetError(IL_COULD_NOT_OPEN_FILE); return bTiff; } //bTiff = ilSaveTiffF(TiffFile); bTiff = iSaveTiffInternal(FileName); iclosew(TiffFile); return bTiff; }
// Internal function used to save the Jpeg. ILboolean iSaveJpegInternal() { struct jpeg_compress_struct JpegInfo; struct jpeg_error_mgr Error; JSAMPROW row_pointer[1]; ILimage *TempImage; ILubyte *TempData; ILenum Type = 0; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } /*if (iGetHint(IL_COMPRESSION_HINT) == IL_USE_COMPRESSION) Quality = 85; // Not sure how low we should dare go... else Quality = 99;*/ if ((iCurImage->Format != IL_RGB && iCurImage->Format != IL_LUMINANCE) || iCurImage->Bpc != 1) { TempImage = iConvertImage(iCurImage, IL_RGB, IL_UNSIGNED_BYTE); if (TempImage == NULL) { return IL_FALSE; } } else { TempImage = iCurImage; } if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT) { TempData = iGetFlipped(TempImage); if (TempData == NULL) { if (TempImage != iCurImage) ilCloseImage(TempImage); return IL_FALSE; } } else { TempData = TempImage->Data; } JpegInfo.err = jpeg_std_error(&Error); // Now we can initialize the JPEG compression object. jpeg_create_compress(&JpegInfo); //jpeg_stdio_dest(&JpegInfo, JpegFile); devil_jpeg_write_init(&JpegInfo); JpegInfo.image_width = TempImage->Width; // image width and height, in pixels JpegInfo.image_height = TempImage->Height; JpegInfo.input_components = TempImage->Bpp; // # of color components per pixel // John Villar's addition if (TempImage->Bpp == 1) JpegInfo.in_color_space = JCS_GRAYSCALE; else JpegInfo.in_color_space = JCS_RGB; jpeg_set_defaults(&JpegInfo); /*#ifndef IL_USE_JPEGLIB_UNMODIFIED Type = iGetInt(IL_JPG_SAVE_FORMAT); if (Type == IL_EXIF) { JpegInfo.write_JFIF_header = FALSE; JpegInfo.write_EXIF_header = TRUE; } else if (Type == IL_JFIF) { JpegInfo.write_JFIF_header = TRUE; JpegInfo.write_EXIF_header = FALSE; } //EXIF not present in libjpeg... #else*/ Type = Type; JpegInfo.write_JFIF_header = TRUE; //#endif//IL_USE_JPEGLIB_UNMODIFIED // Set the quality output jpeg_set_quality(&JpegInfo, iGetInt(IL_JPG_QUALITY), IL_TRUE); // Sets progressive saving here if (ilGetBoolean(IL_JPG_PROGRESSIVE)) jpeg_simple_progression(&JpegInfo); jpeg_start_compress(&JpegInfo, IL_TRUE); //row_stride = image_width * 3; // JSAMPLEs per row in image_buffer while (JpegInfo.next_scanline < JpegInfo.image_height) { // jpeg_write_scanlines expects an array of pointers to scanlines. // Here the array is only one element long, but you could pass // more than one scanline at a time if that's more convenient. row_pointer[0] = &TempData[JpegInfo.next_scanline * TempImage->Bps]; (void) jpeg_write_scanlines(&JpegInfo, row_pointer, 1); } // Step 6: Finish compression jpeg_finish_compress(&JpegInfo); // Step 7: release JPEG compression object // This is an important step since it will release a good deal of memory. jpeg_destroy_compress(&JpegInfo); if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT) ifree(TempData); if (TempImage != iCurImage) ilCloseImage(TempImage); return IL_TRUE; }
ILboolean ilState::GetBool(ILenum Mode) { return ilGetBoolean(Mode); }
// From the DTE sources (mostly by Denton Woods with corrections by Randy Heit) ILboolean iLoadDoomInternal() { ILshort width, height, graphic_header[2], column_loop, row_loop; ILint column_offset, pointer_position, first_pos; ILubyte post, topdelta, length; ILubyte *NewData; ILuint i; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } first_pos = itell(); // Needed to go back to the offset table width = GetLittleShort(); height = GetLittleShort(); graphic_header[0] = GetLittleShort(); // Not even used graphic_header[1] = GetLittleShort(); // Not even used if (!ilTexImage(width, height, 1, 1, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NULL)) { return IL_FALSE; } iCurImage->Origin = IL_ORIGIN_UPPER_LEFT; iCurImage->Pal.Palette = (ILubyte*)ialloc(IL_DOOMPAL_SIZE); if (iCurImage->Pal.Palette == NULL) { return IL_FALSE; } iCurImage->Pal.PalSize = IL_DOOMPAL_SIZE; iCurImage->Pal.PalType = IL_PAL_RGB24; memcpy(iCurImage->Pal.Palette, ilDefaultDoomPal, IL_DOOMPAL_SIZE); // 247 is always the transparent colour (usually cyan) memset(iCurImage->Data, 247, iCurImage->SizeOfData); for (column_loop = 0; column_loop < width; column_loop++) { column_offset = GetLittleInt(); pointer_position = itell(); iseek(first_pos + column_offset, IL_SEEK_SET); while (1) { if (iread(&topdelta, 1, 1) != 1) return IL_FALSE; if (topdelta == 255) break; if (iread(&length, 1, 1) != 1) return IL_FALSE; if (iread(&post, 1, 1) != 1) return IL_FALSE; // Skip extra byte for scaling for (row_loop = 0; row_loop < length; row_loop++) { if (iread(&post, 1, 1) != 1) return IL_FALSE; if (row_loop + topdelta < height) iCurImage->Data[(row_loop+topdelta) * width + column_loop] = post; } iread(&post, 1, 1); // Skip extra scaling byte } iseek(pointer_position, IL_SEEK_SET); } // Converts palette entry 247 (cyan) to transparent. if (ilGetBoolean(IL_CONV_PAL) == IL_TRUE) { NewData = (ILubyte*)ialloc(iCurImage->SizeOfData * 4); if (NewData == NULL) { return IL_FALSE; } for (i = 0; i < iCurImage->SizeOfData; i++) { NewData[i * 4] = iCurImage->Pal.Palette[iCurImage->Data[i]]; NewData[i * 4] = iCurImage->Pal.Palette[iCurImage->Data[i]]; NewData[i * 4] = iCurImage->Pal.Palette[iCurImage->Data[i]]; NewData[i * 4 + 3] = iCurImage->Data[i] != 247 ? 255 : 0; } if (!ilTexImage(iCurImage->Width, iCurImage->Height, iCurImage->Depth, 4, IL_RGBA, iCurImage->Type, NewData)) { ifree(NewData); return IL_FALSE; } iCurImage->Origin = IL_ORIGIN_UPPER_LEFT; ifree(NewData); } ilFixImage(); return IL_TRUE; }
//! Generates a C-style header file for the current image. ILboolean ilSaveCHeader(ILconst_string FileName, char *InternalName) { FILE *HeadFile; ILuint i = 0, j; ILimage *TempImage; const char *Name; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } Name = iGetString(IL_CHEAD_HEADER_STRING); if (Name == NULL) Name = InternalName; if (FileName == NULL || Name == NULL || ilStrLen(FileName) < 1 || ilCharStrLen(Name) < 1) { ilSetError(IL_INVALID_VALUE); return IL_FALSE; } if (!iCheckExtension(FileName, IL_TEXT("h"))) { ilSetError(IL_INVALID_EXTENSION); return IL_FALSE; } if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } if (iCurImage->Bpc > 1) { TempImage = iConvertImage(iCurImage, iCurImage->Format, IL_UNSIGNED_BYTE); if (TempImage == NULL) return IL_FALSE; } else { TempImage = iCurImage; } #ifndef _UNICODE HeadFile = fopen(FileName, "wb"); #else HeadFile = _wfopen(FileName, L"rb"); #endif//_UNICODE if (HeadFile == NULL) { ilSetError(IL_COULD_NOT_OPEN_FILE); return IL_FALSE; } fprintf(HeadFile, "//#include <il/il.h>\n"); fprintf(HeadFile, "// C Image Header:\n\n\n"); fprintf(HeadFile, "// IMAGE_BPP is in bytes per pixel, *not* bits\n"); fprintf(HeadFile, "#define IMAGE_BPP %d\n",iCurImage->Bpp); fprintf(HeadFile, "#define IMAGE_WIDTH %d\n", iCurImage->Width); fprintf(HeadFile, "#define IMAGE_HEIGHT %d\n", iCurImage->Height); fprintf(HeadFile, "#define IMAGE_DEPTH %d\n\n\n", iCurImage->Depth); fprintf(HeadFile, "#define IMAGE_TYPE 0x%X\n", iCurImage->Type); fprintf(HeadFile, "#define IMAGE_FORMAT 0x%X\n\n\n", iCurImage->Format); fprintf(HeadFile, "ILubyte %s[] = {\n", Name); for (; i < TempImage->SizeOfData; i += MAX_LINE_WIDTH) { fprintf(HeadFile, "\t"); for (j = 0; j < MAX_LINE_WIDTH; j++) { if (i + j >= TempImage->SizeOfData - 1) { fprintf(HeadFile, "%4d", TempImage->Data[i+j]); break; } else fprintf(HeadFile, "%4d,", TempImage->Data[i+j]); } fprintf(HeadFile, "\n"); } if (TempImage != iCurImage) ilCloseImage(TempImage); fprintf(HeadFile, "};\n"); if (iCurImage->Pal.Palette && iCurImage->Pal.PalSize && iCurImage->Pal.PalType != IL_PAL_NONE) { fprintf(HeadFile, "\n\n"); fprintf(HeadFile, "#define IMAGE_PALSIZE %u\n\n", iCurImage->Pal.PalSize); fprintf(HeadFile, "#define IMAGE_PALTYPE 0x%X\n\n", iCurImage->Pal.PalType); fprintf(HeadFile, "ILubyte %sPal[] = {\n", Name); for (i = 0; i < iCurImage->Pal.PalSize; i += MAX_LINE_WIDTH) { fprintf(HeadFile, "\t"); for (j = 0; j < MAX_LINE_WIDTH; j++) { if (i + j >= iCurImage->Pal.PalSize - 1) { fprintf(HeadFile, " %4d", iCurImage->Pal.Palette[i+j]); break; } else fprintf(HeadFile, " %4d,", iCurImage->Pal.Palette[i+j]); } fprintf(HeadFile, "\n"); } fprintf(HeadFile, "};\n"); } fclose(HeadFile); return IL_TRUE; }
ILboolean ILAPIENTRY ilSavePal(ILconst_string FileName) { ILstring Ext = iGetExtension(FileName); if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } #ifndef _UNICODE if (FileName == NULL || strlen(FileName) < 1 || Ext == NULL) { #else if (FileName == NULL || wcslen(FileName) < 1 || Ext == NULL) { #endif//_UNICODE ilSetError(IL_INVALID_PARAM); return IL_FALSE; } if (!iCurImage->Pal.Palette || !iCurImage->Pal.PalSize || iCurImage->Pal.PalType == IL_PAL_NONE) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } if (!iStrCmp(Ext, IL_TEXT("pal"))) { return ilSaveJascPal(FileName); } ilSetError(IL_INVALID_EXTENSION); return IL_FALSE; } //! Saves a Paint Shop Pro formatted palette (.pal) file. ILboolean ilSaveJascPal(ILconst_string FileName) { FILE *PalFile; ILuint i, PalBpp, NumCols = ilGetInteger(IL_PALETTE_NUM_COLS); ILubyte *CurPal; if (iCurImage == NULL || NumCols == 0 || NumCols > 256) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } #ifndef _UNICODE if (FileName == NULL || strlen(FileName) < 5) { #else if (FileName == NULL || wcslen(FileName) < 5) { #endif//_UNICODE ilSetError(IL_INVALID_VALUE); return IL_FALSE; } if (!iCheckExtension(FileName, IL_TEXT("pal"))) { ilSetError(IL_INVALID_EXTENSION); return IL_FALSE; } if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } // Create a copy of the current palette and convert it to RGB24 format. CurPal = iCurImage->Pal.Palette; iCurImage->Pal.Palette = (ILubyte*)ialloc(iCurImage->Pal.PalSize); if (!iCurImage->Pal.Palette) { iCurImage->Pal.Palette = CurPal; return IL_FALSE; } memcpy(iCurImage->Pal.Palette, CurPal, iCurImage->Pal.PalSize); if (!ilConvertPal(IL_PAL_RGB24)) { ifree(iCurImage->Pal.Palette); iCurImage->Pal.Palette = CurPal; return IL_FALSE; } #ifndef _UNICODE PalFile = fopen(FileName, "wt"); #else PalFile = _wfopen(FileName, L"wt"); #endif//_UNICODE if (!PalFile) { ilSetError(IL_COULD_NOT_OPEN_FILE); return IL_FALSE; } // Header needed on all .pal files fputs("JASC-PAL\n0100\n256\n", PalFile); PalBpp = ilGetBppPal(iCurImage->Pal.PalType); for (i = 0; i < iCurImage->Pal.PalSize; i += PalBpp) { fprintf(PalFile, "%d %d %d\n", iCurImage->Pal.Palette[i], iCurImage->Pal.Palette[i+1], iCurImage->Pal.Palette[i+2]); } NumCols = 256 - NumCols; for (i = 0; i < NumCols; i++) { fprintf(PalFile, "0 0 0\n"); } ifree(iCurImage->Pal.Palette); iCurImage->Pal.Palette = CurPal; fclose(PalFile); return IL_TRUE; } //! Loads a Halo formatted palette (.pal) file. ILboolean ilLoadHaloPal(ILconst_string FileName) { ILHANDLE HaloFile; HALOHEAD HaloHead; ILushort *TempPal; ILuint i, Size; if (!iCheckExtension(FileName, IL_TEXT("pal"))) { ilSetError(IL_INVALID_EXTENSION); return IL_FALSE; } if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } HaloFile = iopenr(FileName); if (HaloFile == NULL) { ilSetError(IL_COULD_NOT_OPEN_FILE); return IL_FALSE; } if (iread(&HaloHead, sizeof(HALOHEAD), 1) != 1) return IL_FALSE; if (HaloHead.Id != 'A' + ('H' << 8) || HaloHead.Version != 0xe3) { icloser(HaloFile); ilSetError(IL_ILLEGAL_FILE_VALUE); return IL_FALSE; } Size = (HaloHead.MaxIndex + 1) * 3; TempPal = (ILushort*)ialloc(Size * sizeof(ILushort)); if (TempPal == NULL) { icloser(HaloFile); return IL_FALSE; } if (iread(TempPal, sizeof(ILushort), Size) != Size) { icloser(HaloFile); ifree(TempPal); return IL_FALSE; } if (iCurImage->Pal.Palette && iCurImage->Pal.PalSize > 0 && iCurImage->Pal.PalType != IL_PAL_NONE) { ifree(iCurImage->Pal.Palette); iCurImage->Pal.Palette = NULL; } iCurImage->Pal.PalType = IL_PAL_RGB24; iCurImage->Pal.PalSize = Size; iCurImage->Pal.Palette = (ILubyte*)ialloc(iCurImage->Pal.PalSize); if (iCurImage->Pal.Palette == NULL) { icloser(HaloFile); return IL_FALSE; } for (i = 0; i < iCurImage->Pal.PalSize; i++, TempPal++) { iCurImage->Pal.Palette[i] = (ILubyte)*TempPal; } TempPal -= iCurImage->Pal.PalSize; ifree(TempPal); icloser(HaloFile); return IL_TRUE; }
void sgiSwitchData(ILubyte *Data, ILuint SizeOfData) { ILubyte Temp; ILuint i; #ifdef ALTIVEC_GCC i = 0; union { vector unsigned char vec; vector unsigned int load; }inversion_vector; inversion_vector.load = (vector unsigned int)\ {0x01000302,0x05040706,0x09080B0A,0x0D0C0F0E}; while( i <= SizeOfData-16 ) { vector unsigned char data = vec_ld(i,Data); vec_perm(data,data,inversion_vector.vec); vec_st(data,i,Data); i+=16; } SizeOfData -= i; #endif for (i = 0; i < SizeOfData; i += 2) { Temp = Data[i]; Data[i] = Data[i+1]; Data[i+1] = Temp; } return; } /*----------------------------------------------------------------------------*/ // Just an internal convenience function for reading SGI files ILboolean iNewSgi(iSgiHeader *Head) { if (!ilTexImage(Head->XSize, Head->YSize, Head->Bpc, (ILubyte)Head->ZSize, 0, IL_UNSIGNED_BYTE, NULL)) { return IL_FALSE; } iCurImage->Origin = IL_ORIGIN_LOWER_LEFT; switch (Head->ZSize) { case 1: iCurImage->Format = IL_LUMINANCE; break; case 2: iCurImage->Format = IL_LUMINANCE_ALPHA; break; case 3: iCurImage->Format = IL_RGB; break; case 4: iCurImage->Format = IL_RGBA; break; default: ilSetError(IL_ILLEGAL_FILE_VALUE); return IL_FALSE; } switch (Head->Bpc) { case 1: if (Head->PixMin < 0) iCurImage->Type = IL_BYTE; else iCurImage->Type = IL_UNSIGNED_BYTE; break; case 2: if (Head->PixMin < 0) iCurImage->Type = IL_SHORT; else iCurImage->Type = IL_UNSIGNED_SHORT; break; default: ilSetError(IL_ILLEGAL_FILE_VALUE); return IL_FALSE; } iCurImage->Origin = IL_ORIGIN_LOWER_LEFT; return IL_TRUE; } /*----------------------------------------------------------------------------*/ //! Writes a SGI file ILboolean ilSaveSgi(ILconst_string FileName) { ILHANDLE SgiFile; ILboolean bSgi = IL_FALSE; if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) { if (iFileExists(FileName)) { ilSetError(IL_FILE_ALREADY_EXISTS); return IL_FALSE; } } SgiFile = iopenw(FileName); if (SgiFile == NULL) { ilSetError(IL_COULD_NOT_OPEN_FILE); return bSgi; } bSgi = ilSaveSgiF(SgiFile); iclosew(SgiFile); return bSgi; }
ILboolean iLoadMdlInternal() { ILuint Id, Version, NumTex, TexOff, TexDataOff, Position, ImageNum; ILubyte *TempPal; TEX_HEAD TexHead; ILimage *BaseImage=NULL; ILboolean BaseCreated = IL_FALSE; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } Id = GetLittleUInt(); Version = GetLittleUInt(); // 0x54534449 == "IDST" if (Id != 0x54534449 || Version != 10) { ilSetError(IL_INVALID_FILE_HEADER); return IL_FALSE; } // Skips the actual model header. iseek(172, IL_SEEK_CUR); NumTex = GetLittleUInt(); TexOff = GetLittleUInt(); TexDataOff = GetLittleUInt(); if (NumTex == 0 || TexOff == 0 || TexDataOff == 0) { ilSetError(IL_ILLEGAL_FILE_VALUE); return IL_FALSE; } iseek(TexOff, IL_SEEK_SET); for (ImageNum = 0; ImageNum < NumTex; ImageNum++) { if (iread(TexHead.Name, 1, 64) != 64) return IL_FALSE; TexHead.Flags = GetLittleUInt(); TexHead.Width = GetLittleUInt(); TexHead.Height = GetLittleUInt(); TexHead.Offset = GetLittleUInt(); Position = itell(); if (TexHead.Offset == 0) { ilSetError(IL_ILLEGAL_FILE_VALUE); return IL_FALSE; } if (!BaseCreated) { ilTexImage(TexHead.Width, TexHead.Height, 1, 1, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NULL); iCurImage->Origin = IL_ORIGIN_LOWER_LEFT; BaseCreated = IL_TRUE; BaseImage = iCurImage; //iCurImage->NumNext = NumTex - 1; // Don't count the first image. } else { //iCurImage->Next = ilNewImage(TexHead.Width, TexHead.Height, 1, 1, 1); iCurImage = iCurImage->Next; iCurImage->Format = IL_COLOUR_INDEX; iCurImage->Type = IL_UNSIGNED_BYTE; } TempPal = (ILubyte*)ialloc(768); if (TempPal == NULL) { iCurImage = BaseImage; return IL_FALSE; } iCurImage->Pal.Palette = TempPal; iCurImage->Pal.PalSize = 768; iCurImage->Pal.PalType = IL_PAL_RGB24; iseek(TexHead.Offset, IL_SEEK_SET); if (iread(iCurImage->Data, TexHead.Width * TexHead.Height, 1) != 1) return IL_FALSE; if (iread(iCurImage->Pal.Palette, 1, 768) != 768) return IL_FALSE; if (ilGetBoolean(IL_CONV_PAL) == IL_TRUE) { ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE); } iseek(Position, IL_SEEK_SET); } iCurImage = BaseImage; return ilFixImage(); }
void ilFGetBoolean_(int *RetVal, int *Mode) { *RetVal = ilGetBoolean(*Mode); return; }