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; }