ILvoid ILAPIENTRY ilutGetIntegerv(ILenum Mode, ILint *Param)
{
switch (Mode)
{
/*case IL_ORIGIN_MODE:
*Param = ilutStates[ilutCurrentPos].ilutOriginMode;
break;*/
case ILUT_VERSION_NUM:
*Param = ILUT_VERSION;
break;
case ILUT_PALETTE_MODE:
*Param = ilutStates[ilutCurrentPos].ilutUsePalettes;
break;
case ILUT_OPENGL_CONV:
*Param = ilutStates[ilutCurrentPos].ilutOglConv;
break;
case ILUT_GL_USE_S3TC:
*Param = ilutStates[ilutCurrentPos].ilutUseS3TC;
break;
case ILUT_GL_GEN_S3TC:
*Param = ilutStates[ilutCurrentPos].ilutUseS3TC;
break;
case ILUT_S3TC_FORMAT:
*Param = ilutStates[ilutCurrentPos].ilutDXTCFormat;
break;
case ILUT_GL_AUTODETECT_TEXTURE_TARGET:
*Param = ilutStates[ilutCurrentPos].ilutAutodetectTextureTarget;
break;
case ILUT_D3D_MIPLEVELS:
*Param = ilutStates[ilutCurrentPos].D3DMipLevels;
break;
case ILUT_D3D_ALPHA_KEY_COLOR:
*Param = ilutStates[ilutCurrentPos].D3DAlphaKeyColor;
break;
case ILUT_D3D_POOL:
*Param = ilutStates[ilutCurrentPos].D3DPool;
break;
default:
ilSetError(ILUT_INVALID_ENUM);
}
return;
}
ILimage *iluScale3D_(ILimage *Image, ILimage *Scaled, ILuint Width, ILuint Height, ILuint Depth)
{
if (Image == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
ScaleX = (ILfloat)Width / Image->Width;
ScaleY = (ILfloat)Height / Image->Height;
ScaleZ = (ILfloat)Depth / Image->Depth;
//if (iluFilter == ILU_NEAREST)
return iluScale3DNear_(Image, Scaled, Width, Height, Depth);
//else if (iluFilter == ILU_LINEAR)
//return iluScale3DLinear_(Image, Scaled, Width, Height, Depth);
// iluFilter == ILU_BILINEAR
//return iluScale3DBilinear_(Image, Scaled, Width, Height, Depth);
}
//! Sets the default format to be used.
ILboolean ILAPIENTRY ilFormatFunc(ILenum Mode)
{
switch (Mode)
{
//case IL_COLOUR_INDEX:
case IL_RGB:
case IL_RGBA:
case IL_BGR:
case IL_BGRA:
case IL_LUMINANCE:
case IL_LUMINANCE_ALPHA:
ilStates[ilCurrentPos].ilFormatMode = Mode;
break;
default:
ilSetError(IL_INVALID_PARAM);
return IL_FALSE;
}
return IL_TRUE;
}
// Reads a Sun file
ILboolean ilLoad_SUN(ILconst_string FileName)
{
ILHANDLE SunFile;
ILboolean bSun = IL_FALSE;
SunFile = iopenr(FileName);
if (SunFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bSun;
}
iSetInputFile(SunFile);
bSun = ilLoadF_SUN(SunFile);
icloser(SunFile);
return bSun;
}
// Reads an .xpm file
ILboolean ilLoadXpm(const ILstring FileName)
{
ILHANDLE XpmFile;
ILboolean bXpm = IL_FALSE;
XpmFile = iopenr(FileName);
if (XpmFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bXpm;
}
iSetInputFile(XpmFile);
bXpm = ilLoadXpmF(XpmFile);
icloser(XpmFile);
return bXpm;
}
ILvoid ILAPIENTRY ilRegisterType(ILenum Type)
{
switch (Type)
{
case IL_BYTE:
case IL_UNSIGNED_BYTE:
case IL_SHORT:
case IL_UNSIGNED_SHORT:
case IL_INT:
case IL_UNSIGNED_INT:
case IL_FLOAT:
case IL_DOUBLE:
iCurImage->Type = Type;
break;
default:
ilSetError(IL_INVALID_ENUM);
}
return;
}
//! Sets the default type to be used.
ILboolean ILAPIENTRY ilTypeFunc(ILenum Mode)
{
switch (Mode)
{
case IL_BYTE:
case IL_UNSIGNED_BYTE:
case IL_SHORT:
case IL_UNSIGNED_SHORT:
case IL_INT:
case IL_UNSIGNED_INT:
case IL_FLOAT:
case IL_DOUBLE:
ilStates[ilCurrentPos].ilTypeMode = Mode;
break;
default:
ilSetError(IL_INVALID_PARAM);
return IL_FALSE;
}
return IL_TRUE;
}
// Internal function to load a raw image
ILboolean iLoadRawInternal()
{
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
iCurImage->Width = GetLittleUInt();
iCurImage->Height = GetLittleUInt();
iCurImage->Depth = GetLittleUInt();
iCurImage->Bpp = igetc();
if (iread(&iCurImage->Bpc, 1, 1) != 1)
return IL_FALSE;
if (!ilTexImage(iCurImage->Width, iCurImage->Height, iCurImage->Depth, iCurImage->Bpp, 0, ilGetTypeBpc(iCurImage->Bpc), NULL)) {
return IL_FALSE;
}
iCurImage->Origin = IL_ORIGIN_LOWER_LEFT;
// Tries to read the correct amount of data
if (iread(iCurImage->Data, 1, iCurImage->SizeOfData) < iCurImage->SizeOfData)
return IL_FALSE;
if (ilIsEnabled(IL_ORIGIN_SET)) {
iCurImage->Origin = ilGetInteger(IL_ORIGIN_MODE);
}
else {
iCurImage->Origin = IL_ORIGIN_UPPER_LEFT;
}
if (iCurImage->Bpp == 1)
iCurImage->Format = IL_LUMINANCE;
else if (iCurImage->Bpp == 3)
iCurImage->Format = IL_RGB;
else // 4
iCurImage->Format = IL_RGBA;
ilFixImage();
return IL_TRUE;
}
//! Returns a constant string detailing aspects about this library.
ILconst_string ILAPIENTRY ilGetString(ILenum StringName)
{
switch (StringName)
{
case IL_VENDOR:
return (ILconst_string)_ilVendor;
case IL_VERSION_NUM: //changed 2003-08-30: IL_VERSION changes //switch define ;-)
return (ILconst_string)_ilVersion;
case IL_LOAD_EXT:
return (ILconst_string)_ilLoadExt;
case IL_SAVE_EXT:
return (ILconst_string)_ilSaveExt;
case IL_TGA_ID_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilTgaId;
case IL_TGA_AUTHNAME_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilTgaAuthName;
case IL_TGA_AUTHCOMMENT_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilTgaAuthComment;
case IL_PNG_AUTHNAME_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilPngAuthName;
case IL_PNG_TITLE_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilPngTitle;
case IL_PNG_DESCRIPTION_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilPngDescription;
//2003-08-31: added tif strings
case IL_TIF_DESCRIPTION_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilTifDescription;
case IL_TIF_HOSTCOMPUTER_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilTifHostComputer;
case IL_TIF_DOCUMENTNAME_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilTifDocumentName;
case IL_TIF_AUTHNAME_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilTifAuthName;
case IL_CHEAD_HEADER_STRING:
return (ILconst_string)ilStates[ilCurrentPos].ilCHeader;
default:
ilSetError(IL_INVALID_ENUM);
break;
}
return NULL;
}
ILint ILAPIENTRY iWriteLump(const void *Buffer, ILuint Size, ILuint Number, ILHANDLE h)
{
ILuint SizeBytes = Size * Number;
ILuint i = 0;
for (; i < SizeBytes; i++) {
if (iCurImage->io.lumpSize > 0) {
if (iCurImage->io.lumpPos + i >= iCurImage->io.lumpSize) { // Should we use > instead?
ilSetError(IL_FILE_WRITE_ERROR);
iCurImage->io.lumpPos += i;
return i;
}
}
*((ILubyte*)iCurImage->io.lump + iCurImage->io.lumpPos + i) = *((ILubyte*)Buffer + i);
}
iCurImage->io.lumpPos += SizeBytes;
return SizeBytes;
}
ILvoid ILAPIENTRY ilRegisterPal(ILvoid *Pal, ILuint Size, ILenum Type)
{
if (!iCurImage->Pal.Palette || !iCurImage->Pal.PalSize || iCurImage->Pal.PalType != IL_PAL_NONE) {
ifree(iCurImage->Pal.Palette);
}
iCurImage->Pal.PalSize = Size;
iCurImage->Pal.PalType = Type;
iCurImage->Pal.Palette = (ILubyte*)ialloc(Size);
if (iCurImage->Pal.Palette == NULL)
return;
if (Pal != NULL) {
memcpy(iCurImage->Pal.Palette, Pal, Size);
}
else {
ilSetError(IL_INVALID_PARAM);
}
return;
}
ILAPI ILpal* ILAPIENTRY iCopyPal()
{
ILpal *Pal;
if (iCurImage == NULL || iCurImage->Pal.Palette == NULL ||
iCurImage->Pal.PalSize == 0 || iCurImage->Pal.PalType == IL_PAL_NONE) {
ilSetError(IL_ILLEGAL_OPERATION);
return NULL;
}
Pal = (ILpal*)ialloc(sizeof(ILpal));
if (Pal == NULL) {
return NULL;
}
if (!iCopyPalette(Pal, &iCurImage->Pal)) {
ifree(Pal);
return NULL;
}
return Pal;
}
ILboolean ilSaveJpeg(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);
}
// Creates a copy of Src and returns it.
ILAPI ILimage* ILAPIENTRY ilCopyImage_(ILimage *Src)
{
ILimage *Dest;
if (Src == NULL) {
ilSetError(IL_INVALID_PARAM);
return NULL;
}
Dest = ilNewImage(Src->Width, Src->Height, Src->Depth, Src->Bpp, Src->Bpc);
if (Dest == NULL) {
return NULL;
}
if (ilCopyImageAttr(Dest, Src) == IL_FALSE)
return NULL;
memcpy(Dest->Data, Src->Data, Src->SizeOfData);
return Dest;
}
ILint ILAPIENTRY iWriteLump(const ILvoid *Buffer, ILuint Size, ILuint Number)
{
ILuint SizeBytes = Size * Number;
ILuint i = 0;
for (; i < SizeBytes; i++) {
if (WriteLumpSize > 0) {
if (WriteLumpPos + i >= WriteLumpSize) { // Should we use > instead?
ilSetError(IL_FILE_WRITE_ERROR);
WriteLumpPos += i;
return i;
}
}
*((ILubyte*)WriteLump + WriteLumpPos + i) = *((ILubyte*)Buffer + i);
}
WriteLumpPos += SizeBytes;
return SizeBytes;
}
ILuint iGetActiveNum(ILenum Type)
{
ILimage *BaseImage;
ILuint Num = 0;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return 0;
}
BaseImage = iGetBaseImage();
if (BaseImage == iCurImage)
return 0;
switch (Type)
{
case IL_ACTIVE_IMAGE:
BaseImage = BaseImage->Next;
break;
case IL_ACTIVE_MIPMAP:
BaseImage = BaseImage->Mipmaps;
break;
case IL_ACTIVE_LAYER:
BaseImage = BaseImage->Layers;
break;
}
do {
if (BaseImage == NULL)
return 0;
Num++;
if (BaseImage == iCurImage)
return Num;
} while ((BaseImage = BaseImage->Next));
//ilSetError(IL_ILLEGAL_OPERATION);
return 0;
}
ILAPI ILboolean ILAPIENTRY ilInitImage(ILimage *Image, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, void *Data)
{
ILubyte BpcType = ilGetBpcType(Type);
if (BpcType == 0) {
ilSetError(IL_INVALID_PARAM);
return IL_FALSE;
}
memset(Image, 0, sizeof(ILimage));
////
if (Width == 0) Width = 1;
if (Height == 0) Height = 1;
if (Depth == 0) Depth = 1;
Image->Width = Width;
Image->Height = Height;
Image->Depth = Depth;
Image->Bpp = Bpp;
Image->Bpc = BpcType;
Image->Bps = Width * Bpp * Image->Bpc;
Image->SizeOfPlane = Image->Bps * Height;
Image->SizeOfData = Image->SizeOfPlane * Depth;
Image->Format = Format;
Image->Type = Type;
Image->Origin = IL_ORIGIN_LOWER_LEFT;
Image->Pal.PalType = IL_PAL_NONE;
Image->DxtcFormat = IL_DXT_NO_COMP;
Image->DxtcData = NULL;
Image->Data = (ILubyte*)ialloc(Image->SizeOfData);
if (Image->Data == NULL) {
return IL_FALSE;
}
if (Data != NULL) {
memcpy(Image->Data, Data, Image->SizeOfData);
}
return IL_TRUE;
}
// Internal function used to load the jpeg.
ILboolean iLoadJpegInternal()
{
struct jpeg_error_mgr Error;
struct jpeg_decompress_struct JpegInfo;
ILboolean result;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
JpegInfo.err = jpeg_std_error(&Error); // init standard error handlers
Error.error_exit = iJpegErrorExit; // add our exit handler
Error.output_message = OutputMsg;
if ((result = setjmp(JpegJumpBuffer) == 0) != IL_FALSE) {
jpeg_create_decompress(&JpegInfo);
JpegInfo.do_block_smoothing = IL_TRUE;
JpegInfo.do_fancy_upsampling = IL_TRUE;
//jpeg_stdio_src(&JpegInfo, iGetFile());
devil_jpeg_read_init(&JpegInfo);
jpeg_read_header(&JpegInfo, IL_TRUE);
result = ilLoad_FROM_JPEG_STRUCT(&JpegInfo);
jpeg_finish_decompress(&JpegInfo);
jpeg_destroy_decompress(&JpegInfo);
}
else
{
jpeg_destroy_decompress(&JpegInfo);
}
//return ilFixImage(); // No need to call it again (called first in ilLoadFromJpegStruct).
return result;
}
ILvoid ILAPIENTRY iluRegioniv(ILpointi *Points, ILuint n)
{
if (Points == NULL || n == 0) {
ifree(RegionPointsi);
ifree(RegionPointsf);
RegionPointsi = NULL;
PointNum = 0;
return;
}
if (n < 3) {
ilSetError(ILU_INVALID_PARAM);
return;
}
ifree(RegionPointsi);
ifree(RegionPointsf);
RegionPointsi = (ILpointi*)ialloc(sizeof(ILpointi) * n);
if (RegionPointsi == NULL)
return;
memcpy(RegionPointsi, Points, sizeof(ILpointi) * n);
PointNum = n;
return;
}
//! Reads a Doom file
ILboolean ilLoadDoom(ILconst_string FileName)
{
ILHANDLE DoomFile;
ILboolean bDoom = IL_FALSE;
// Not sure of any kind of specified extension...maybe .lmp?
/*if (!iCheckExtension(FileName, "")) {
ilSetError(IL_INVALID_EXTENSION);
return NULL;
}*/
DoomFile = iopenr(FileName);
if (DoomFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bDoom;
}
bDoom = ilLoadDoomF(DoomFile);
icloser(DoomFile);
return bDoom;
}
// Internal function used to save the Mng.
ILboolean iSaveMngInternal()
{
//mng_handle mng;
// Not working yet, so just error out.
ilSetError(IL_INVALID_EXTENSION);
return IL_FALSE;
//if (iCurImage == NULL) {
// ilSetError(IL_ILLEGAL_OPERATION);
// return IL_FALSE;
//}
//mng = mng_initialize(MNG_NULL, mymngalloc, mymngfree, MNG_NULL);
//if (mng == MNG_NULL) {
// ilSetError(IL_LIB_MNG_ERROR);
// return IL_FALSE;
//}
//mng_setcb_openstream(mng, mymngopenstreamwrite);
//mng_setcb_closestream(mng, mymngclosestream);
//mng_setcb_writedata(mng, mymngwritedata);
//// Write File:
// mng_create(mng);
//// Check return value.
//mng_putchunk_mhdr(mng, iCurImage->Width, iCurImage->Height, 1000, 3, 1, 3, 0x0047);
//mng_putchunk_basi(mng, iCurImage->Width, iCurImage->Height, 8, MNG_COLORTYPE_RGB, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 1);
//mng_putchunk_iend(mng);
//mng_putimgdata_ihdr(mng, iCurImage->Width, iCurImage->Height, MNG_COLORTYPE_RGB, 8, 0, 0, 0, 0, mymnggetcanvasline);
//// Now write file:
//mng_write(mng);
//mng_cleanup(&mng);
//return IL_TRUE;
}
//! Reads a raw data file
ILboolean ILAPIENTRY ilLoadData(ILconst_string FileName, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp)
{
ILHANDLE RawFile;
ILboolean bRaw = IL_FALSE;
// No need to check for raw data
/*if (!iCheckExtension(FileName, "raw")) {
ilSetError(IL_INVALID_EXTENSION);
return bRaw;
}*/
RawFile = iCurImage->io.openReadOnly(FileName);
if (RawFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bRaw;
}
bRaw = ilLoadDataF(RawFile, Width, Height, Depth, Bpp);
iCurImage->io.close(RawFile);
return bRaw;
}
// ONLY call at startup.
ILvoid ILAPIENTRY ilInit()
{
// if it is already initialized skip initialization
if (IsInit == IL_TRUE )
return;
//ilSetMemory(NULL, NULL); Now useless 3/4/2006 (due to modification in il_alloc.c)
ilSetError(IL_NO_ERROR);
ilDefaultStates(); // Set states to their defaults.
// Sets default file-reading callbacks.
ilResetRead();
ilResetWrite();
#if (!defined(_WIN32_WCE)) && (!defined(IL_STATIC_LIB))
atexit((void*)ilRemoveRegistered);
#endif
//_WIN32_WCE
//ilShutDown();
iSetImage0(); // Beware! Clears all existing textures!
iBindImageTemp(); // Go ahead and create the temporary image.
IsInit = IL_TRUE;
return;
}
//! Reads a raw file
ILboolean ilLoadRaw(const ILstring FileName)
{
ILHANDLE RawFile;
ILboolean bRaw = IL_FALSE;
// No need to check for raw
/*if (!iCheckExtension(FileName, "raw")) {
ilSetError(IL_INVALID_EXTENSION);
return bRaw;
}*/
RawFile = iopenr(FileName);
if (RawFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bRaw;
}
bRaw = ilLoadRawF(RawFile);
icloser(RawFile);
return bRaw;
}
char *iff_decompress_tile_rle(ILushort width, ILushort height, ILushort depth,
char *compressedData, ILuint compressedDataSize)
{
char *channels[4];
char *data;
int i, k, row, column;
ILuint compressedStart = 0;
// Decompress only in RGBA.
if (depth != 4) {
ilSetError(IL_ILLEGAL_FILE_VALUE);
return NULL;
}
for (i = depth-1; i >= 0; --i) {
channels[i] = iff_decompress_rle(width * height, compressedData,
compressedDataSize, &compressedStart);
if (channels[i] == NULL)
return NULL;
}
// Build all the channels from the decompression into an RGBA array.
data = ialloc(width * height * depth * sizeof(char));
if (data == NULL)
return NULL;
for (row = 0; row < height; row++)
for (column = 0; column < width; column++)
for (k = 0; k < depth; k++)
data[depth*(row*width + column) + k] =
channels[k][row*width + column];
ifree(channels[0]); ifree(channels[1]);
ifree(channels[2]); ifree(channels[3]);
return data;
}
ILboolean iLoadLifInternal()
{
LIF_HEAD LifHead;
ILuint i;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (!iGetLifHead(&LifHead))
return IL_FALSE;
if (!ilTexImage(LifHead.Width, LifHead.Height, 1, 1, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NULL)) {
return IL_FALSE;
}
iCurImage->Origin = IL_ORIGIN_UPPER_LEFT;
iCurImage->Pal.Palette = (ILubyte*)ialloc(1024);
if (iCurImage->Pal.Palette == NULL)
return IL_FALSE;
iCurImage->Pal.PalSize = 1024;
iCurImage->Pal.PalType = IL_PAL_RGBA32;
if (iread(iCurImage->Data, LifHead.Width * LifHead.Height, 1) != 1)
return IL_FALSE;
if (iread(iCurImage->Pal.Palette, 1, 1024) != 1024)
return IL_FALSE;
// Each data offset is offset by -1, so we add one.
for (i = 0; i < iCurImage->SizeOfData; i++) {
iCurImage->Data[i]++;
}
ilFixImage();
return IL_TRUE;
}
// File Get Word
// MaxLen must be greater than 1, because the trailing NULL is always stored.
char *iFgetw(ILubyte *Buff, ILint MaxLen, FILE *File)
{
ILint Temp;
ILint i;
if (Buff == NULL || File == NULL || MaxLen < 2) {
ilSetError(IL_INVALID_PARAM);
return NULL;
}
for (i = 0; i < MaxLen - 1; i++) {
Temp = fgetc(File);
if (Temp == '\n' || Temp == '\0' || Temp == IL_EOF || feof(File)) {
break;
}
if (Temp == ' ') {
while (Temp == ' ') { // Just to get rid of any extra spaces
Temp = fgetc(File);
}
fseek(File, -1, IL_SEEK_CUR); // Go back one
break;
}
if (!isprint(Temp)) { // Skips any non-printing characters
while (!isprint(Temp)) {
Temp = fgetc(File);
}
fseek(File, -1, IL_SEEK_CUR);
break;
}
Buff[i] = Temp;
}
Buff[i] = '\0';
return (char *)Buff;
}
ILboolean ILAPIENTRY iluBlurGaussian(ILuint Iter)
{
ILubyte *Data;
ILuint i;
ILboolean Palette = IL_FALSE, Converted = IL_FALSE;
ILenum Type = 0;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iluCurImage->Format == IL_COLOUR_INDEX) {
Palette = IL_TRUE;
ilConvertImage(ilGetPalBaseType(iluCurImage->Pal.PalType), IL_UNSIGNED_BYTE);
}
else if (iluCurImage->Type > IL_UNSIGNED_BYTE) {
Converted = IL_TRUE;
Type = iluCurImage->Type;
ilConvertImage(iluCurImage->Format, IL_UNSIGNED_BYTE);
}
for (i = 0; i < Iter; i++) {
Data = Filter(iluCurImage, filter_gaussian, filter_gaussian_scale, filter_gaussian_bias );
if (!Data)
return IL_FALSE;
ifree(iluCurImage->Data);
iluCurImage->Data = Data;
}
if (Palette)
ilConvertImage(IL_COLOUR_INDEX, IL_UNSIGNED_BYTE);
else if (Converted)
ilConvertImage(iluCurImage->Format, Type);
return IL_TRUE;
}
// Internal function used to load the FTX.
ILboolean iLoadFtxInternal(void)
{
ILuint Width, Height, HasAlpha;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
Width = GetLittleUInt();
Height = GetLittleUInt();
HasAlpha = GetLittleUInt(); // Kind of backwards from what I would think...
//@TODO: Right now, it appears that all images are in RGBA format. See if I can find specs otherwise
// or images that load incorrectly like this.
//if (HasAlpha == 0) { // RGBA format
if (!ilTexImage(Width, Height, 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, NULL))
return IL_FALSE;
//}
//else if (HasAlpha == 1) { // RGB format
// if (!ilTexImage(Width, Height, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL))
// return IL_FALSE;
//}
//else { // Unknown format
// ilSetError(IL_INVALID_FILE_HEADER);
// return IL_FALSE;
//}
// The origin will always be in the upper left.
iCurImage->Origin = IL_ORIGIN_UPPER_LEFT;
// All we have to do for this format is read the raw, uncompressed data.
if (iread(iCurImage->Data, 1, iCurImage->SizeOfData) != iCurImage->SizeOfData)
return IL_FALSE;
return ilFixImage();
}
IDirect3DVolumeTexture8* ILAPIENTRY ilutD3D8VolumeTexture(IDirect3DDevice8 *Device)
{
IDirect3DVolumeTexture8 *Texture;
D3DLOCKED_BOX Box;
D3DFORMAT Format;
ILimage *Image;
ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return NULL;
}
if (!FormatsDX8Checked)
CheckFormatsDX8(Device);
Image = MakeD3D8Compliant(Device, &Format);
if (Image == NULL)
return NULL;
if (FAILED(IDirect3DDevice8_CreateVolumeTexture(Device, Image->Width, Image->Height,
Image->Depth, 1, 0, Format, ilutGetInteger(ILUT_D3D_POOL), &Texture)))
return NULL;
if (FAILED(IDirect3DVolumeTexture8_LockBox(Texture, 0, &Box, NULL, 0)))
return NULL;
memcpy(Box.pBits, Image->Data, Image->SizeOfData);
if (!IDirect3DVolumeTexture8_UnlockBox(Texture, 0))
return IL_FALSE;
// We don't want to have mipmaps for such a large image.
if (Image != ilutCurImage)
ilCloseImage(Image);
return Texture;
}
