ID3D10Texture2D* ILAPIENTRY ilutD3D10Texture(ID3D10Device *Device)
{
ID3D10Texture2D *Texture;
DXGI_FORMAT Format;
ILimage *Image;
Image = ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return NULL;
}
if (!FormatsDX10Checked)
CheckFormatsDX10(Device);
Image = MakeD3D10Compliant(Device, &Format);
if (Image == NULL) {
if (Image != ilutCurImage)
ilCloseImage(Image);
return NULL;
}
Texture = iD3D10MakeTexture(Device, Image->Data, Image->Width, Image->Height, Format, 1); //@TODO: The 1 should be ilutGetInteger(ILUT_D3D_MIPLEVELS).
if (!Texture)
return NULL;
//iD3D10CreateMipmaps(Texture, Image);
//success:
if (Image != ilutCurImage)
ilCloseImage(Image);
return Texture;
}
//! Retrieves information about the current bound image.
void ILAPIENTRY iluGetImageInfo(ILinfo *Info)
{
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL || Info == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return;
}
Info->Id = ilGetCurName();
Info->Data = ilGetData();
Info->Width = iluCurImage->Width;
Info->Height = iluCurImage->Height;
Info->Depth = iluCurImage->Depth;
Info->Bpp = iluCurImage->Bpp;
Info->SizeOfData = iluCurImage->SizeOfData;
Info->Format = iluCurImage->Format;
Info->Type = iluCurImage->Type;
Info->Origin = iluCurImage->Origin;
Info->Palette = iluCurImage->Pal.Palette;
Info->PalType = iluCurImage->Pal.PalType;
Info->PalSize = iluCurImage->Pal.PalSize;
iGetIntegervImage(iluCurImage, IL_NUM_IMAGES,
(ILint*)&Info->NumNext);
iGetIntegervImage(iluCurImage, IL_NUM_MIPMAPS,
(ILint*)&Info->NumMips);
iGetIntegervImage(iluCurImage, IL_NUM_LAYERS,
(ILint*)&Info->NumLayers);
return;
}
// Sharpens when Factor is in the range [1.0, 2.5].
// Blurs when Factor is in the range [0.0, 1.0].
ILboolean ILAPIENTRY iluSharpen(ILfloat Factor, ILuint Iter)
{
ILimage *Blur, *CurImage; // iluBlur() changes iluCurImage
ILuint i;
CurImage = ilGetCurImage();
if (CurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
Blur = ilNewImage(CurImage->Width, CurImage->Height, CurImage->Depth, CurImage->Bpp, CurImage->Bpc);
if (Blur == NULL) {
return IL_FALSE;
}
ilCopyImageAttr(Blur, CurImage);
ilCopyPixels(0, 0, 0, CurImage->Width, CurImage->Height, 1, CurImage->Format, CurImage->Type, Blur->Data);
ilSetCurImage(Blur);
iluBlurGaussian(1);
for (i = 0; i < Iter; i++) {
iIntExtImg(Blur, CurImage, Factor);
}
ilCloseImage(Blur);
ilSetCurImage(CurImage);
return IL_TRUE;
}
ILboolean ILAPIENTRY iluEdgeDetectE()
{
ILubyte *Data;
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);
}
Data = Filter(iluCurImage, filter_embossedge, filter_embossedge_scale, filter_embossedge_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;
}
// Works best when Contrast is in the range [-0.5, 1.7].
ILboolean ILAPIENTRY iluContrast(ILfloat Contrast)
{
ILimage *Grey;
ILuint i;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
Grey = ilNewImage(iluCurImage->Width, iluCurImage->Height, iluCurImage->Depth, iluCurImage->Bpp, iluCurImage->Bpc);
if (Grey == NULL) {
return IL_FALSE;
}
// Make Grey all 127's
for (i = 0; i < Grey->SizeOfData; i++) {
Grey->Data[i] = 127;
}
iIntExtImg(Grey, iluCurImage, Contrast);
ilCloseImage(Grey);
return IL_TRUE;
}
//------------------------------------------------------------------------------------
// Scales the image or current mipmap.
//------------------------------------------------------------------------------------
u32 Image::Scale( u32 Width, u32 Height, u32 Depth, u32 MipMapLevel /*= 0*/ )
{
ilBindImage(m_iImgID);
if (!ilActiveMipmap(MipMapLevel))
{
CheckDevilErrors(m_pFileName);
io::Logger::Log(io::ELM_Error, "Incorrect mipmap level for image=%", m_pName);
return 0;
}
//iluImageParameter(ILU_FILTER, ILU_SCALE_BOX);
ILimage *ret = ilGetCurImage();
ILimage *Temp = NULL;//iluScale_(ret, Width, Height, Depth);
if (!ret)
return false;
if (!ilTexImage(Temp->Width, Temp->Height, Temp->Depth, Temp->Bpp, Temp->Format, Temp->Type, Temp->Data))
{
return false;
}
if (MipMapLevel == 0)
{
m_iWidth = Width;
m_iHeight = Height;
}
return true;
} // Scale
ILboolean ILAPIENTRY iluSaturate4f(ILfloat r, ILfloat g, ILfloat b, ILfloat Saturation)
{
ILfloat Mat[4][4];
ILfloat s = Saturation;
Mat[0][0] = (1.0f - s) * r + s;
Mat[0][1] = (1.0f - s) * r;
Mat[0][2] = (1.0f - s) * r;
Mat[0][3] = 0.0f;
Mat[1][0] = (1.0f - s) * g;
Mat[1][1] = (1.0f - s) * g + s;
Mat[1][2] = (1.0f - s) * g;
Mat[1][3] = 0.0f;
Mat[2][0] = (1.0f - s) * b;
Mat[2][1] = (1.0f - s) * b;
Mat[2][2] = (1.0f - s) * b + s;
Mat[2][3] = 0.0f;
Mat[3][0] = 0.0f;
Mat[3][1] = 0.0f;
Mat[3][2] = 0.0f;
Mat[3][3] = 1.0f;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
iApplyMatrix(iluCurImage, Mat);
return IL_TRUE;
}
// Does not account for converting luminance...
BITMAP* ILAPIENTRY ilutConvertToAlleg(PALETTE Pal)
{
BITMAP *Bitmap;
ILimage *TempImage;
ILuint i = 0, j = 0;
ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return NULL;
}
// Should be IL_BGR(A), but Djgpp screws up somewhere along the line.
if (ilutCurImage->Format == IL_RGB || ilutCurImage->Format == IL_RGBA) {
iluSwapColours();
}
if (ilutCurImage->Origin == IL_ORIGIN_LOWER_LEFT)
iluFlipImage();
if (ilutCurImage->Type > IL_UNSIGNED_BYTE) {} // Can't do anything about this right now...
if (ilutCurImage->Type == IL_BYTE) {} // Can't do anything about this right now...
Bitmap = create_bitmap_ex(ilutCurImage->Bpp * 8, ilutCurImage->Width, ilutCurImage->Height);
if (Bitmap == NULL) {
return IL_FALSE;
}
memcpy(Bitmap->dat, ilutCurImage->Data, ilutCurImage->SizeOfData);
// Should we make this toggleable?
if (ilutCurImage->Bpp == 8 && ilutCurImage->Pal.PalType != IL_PAL_NONE) {
// Use the image's palette if there is one
// ilConvertPal is destructive to the original image
// @TODO: Use new ilCopyPal!!!
TempImage = ilNewImage(ilutCurImage->Width, ilutCurImage->Height, ilutCurImage->Depth, ilutCurImage->Bpp, 1);
ilCopyImageAttr(TempImage, ilutCurImage);
ilSetCurImage(TempImage);
if (!ilConvertPal(IL_PAL_RGB24)) {
destroy_bitmap(Bitmap);
ilSetError(ILUT_ILLEGAL_OPERATION);
return NULL;
}
for (; i < ilutCurImage->Pal.PalSize && i < 768; i += 3, j++) {
Pal[j].r = TempImage->Pal.Palette[i+0];
Pal[j].g = TempImage->Pal.Palette[i+1];
Pal[j].b = TempImage->Pal.Palette[i+2];
Pal[j].filler = 255;
}
ilCloseImage(TempImage);
ilSetCurImage(ilutCurImage);
}
return Bitmap;
}
ILboolean ILAPIENTRY iluRotate(ILfloat Angle)
{
ILimage *Temp, *Temp1, *CurImage = NULL;
ILenum PalType = 0;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iluCurImage->Format == IL_COLOUR_INDEX) {
PalType = iluCurImage->Pal.PalType;
CurImage = iluCurImage;
iluCurImage = iConvertImage(iluCurImage, ilGetPalBaseType(CurImage->Pal.PalType), IL_UNSIGNED_BYTE);
}
Temp = iluRotate_(iluCurImage, Angle);
if (Temp != NULL) {
if (PalType != 0) {
ilCloseImage(iluCurImage);
Temp1 = iConvertImage(Temp, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE);
ilCloseImage(Temp);
Temp = Temp1;
ilSetCurImage(CurImage);
}
ilTexImage(Temp->Width, Temp->Height, Temp->Depth, Temp->Bpp, Temp->Format, Temp->Type, Temp->Data);
if (PalType != 0) {
iluCurImage = ilGetCurImage();
iluCurImage->Pal.PalSize = Temp->Pal.PalSize;
iluCurImage->Pal.PalType = Temp->Pal.PalType;
iluCurImage->Pal.Palette = (ILubyte*)ialloc(Temp->Pal.PalSize);
if (iluCurImage->Pal.Palette == NULL) {
ilCloseImage(Temp);
return IL_FALSE;
}
memcpy(iluCurImage->Pal.Palette, Temp->Pal.Palette, Temp->Pal.PalSize);
}
iluCurImage->Origin = Temp->Origin;
ilCloseImage(Temp);
return IL_TRUE;
}
return IL_FALSE;
}
ILboolean ILAPIENTRY iluEdgeDetectP()
{
ILubyte *HPass, *VPass;
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);
}
HPass = Filter(iluCurImage, filter_h_prewitt, filter_h_prewitt_scale, filter_h_prewitt_bias);
VPass = Filter(iluCurImage, filter_v_prewitt, filter_v_prewitt_scale, filter_v_prewitt_bias);
if (!HPass || !VPass) {
ifree(HPass);
ifree(VPass);
return IL_FALSE;
}
// Combine the two passes
// Optimization by Matt Denham
for (i = 0; i < iluCurImage->SizeOfData; i++) {
if (HPass[i] == 0)
iluCurImage->Data[i] = VPass[i];
else if (VPass[i] == 0)
iluCurImage->Data[i] = HPass[i];
else
iluCurImage->Data[i] = (ILubyte)sqrt(HPass[i]*HPass[i]+VPass[i]*VPass[i]);
}
/*for (i = 0; i < iluCurImage->SizeOfData; i++) {
iluCurImage->Data[i] = (ILubyte)sqrt(HPass[i]*HPass[i]+VPass[i]*VPass[i]);
}*/
ifree(HPass);
ifree(VPass);
if (Palette)
ilConvertImage(IL_COLOUR_INDEX, IL_UNSIGNED_BYTE);
else if (Converted)
ilConvertImage(iluCurImage->Format, Type);
return IL_TRUE;
}
ILboolean ILAPIENTRY iluEnlargeImage(ILfloat XDim, ILfloat YDim, ILfloat ZDim)
{
if (XDim <= 0.0f || YDim <= 0.0f || ZDim <= 0.0f) {
ilSetError(ILU_INVALID_PARAM);
return IL_FALSE;
}
iluCurImage = ilGetCurImage();
return iluScale((ILuint)(iluCurImage->Width * XDim), (ILuint)(iluCurImage->Height * YDim),
(ILuint)(iluCurImage->Depth * ZDim));
}
ILAPI ILimage* ILAPIENTRY iluScale_(ILimage *Image, ILuint Width, ILuint Height, ILuint Depth)
{
ILimage *Scaled, *CurImage, *ToScale;
ILenum Format, PalType;
CurImage = ilGetCurImage();
Format = Image->Format;
if (Format == IL_COLOUR_INDEX) {
ilSetCurImage(Image);
PalType = Image->Pal.PalType;
ToScale = iConvertImage(iluCurImage, ilGetPalBaseType(Image->Pal.PalType), iluCurImage->Type);
}
else {
ToScale = Image;
}
// So we don't replicate this 3 times (one in each iluScalexD_() function.
Scaled = (ILimage*)icalloc(1, sizeof(ILimage));
if (ilCopyImageAttr(Scaled, ToScale) == IL_FALSE) {
ilCloseImage(Scaled);
if (ToScale != Image)
ilCloseImage(ToScale);
ilSetCurImage(CurImage);
return NULL;
}
if (ilResizeImage(Scaled, Width, Height, Depth, ToScale->Bpp, ToScale->Bpc) == IL_FALSE) {
ilCloseImage(Scaled);
if (ToScale != Image)
ilCloseImage(ToScale);
ilSetCurImage(CurImage);
return NULL;
}
if (Height <= 1 && Image->Height <= 1) {
iluScale1D_(ToScale, Scaled, Width);
}
if (Depth <= 1 && Image->Depth <= 1) {
iluScale2D_(ToScale, Scaled, Width, Height);
}
else {
iluScale3D_(ToScale, Scaled, Width, Height, Depth);
}
if (Format == IL_COLOUR_INDEX) {
//ilSetCurImage(Scaled);
//ilConvertImage(IL_COLOUR_INDEX);
ilSetCurImage(CurImage);
ilCloseImage(ToScale);
}
return Scaled;
}
ILboolean ILAPIENTRY iluGammaCorrect(ILfloat Gamma)
{
ILfloat Table[256];
ILuint i, NumPix;
ILushort *ShortPtr;
ILuint *IntPtr;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
for (i = 0; i < 256; i++) {
Table[i] = (ILfloat)pow(i / 255.0, 1.0 / Gamma);
}
// Do we need to clamp here?
if (iluCurImage->Format == IL_COLOUR_INDEX) {
for (i = 0; i < iluCurImage->Pal.PalSize; i++) {
iluCurImage->Pal.Palette[i] = (ILubyte)(Table[iluCurImage->Pal.Palette[i]] * 255);
}
}
else {
// Not too sure if this is the correct way of handling multiple bpc's.
switch (iluCurImage->Bpc)
{
case 1:
for (i = 0; i < iluCurImage->SizeOfData; i++) {
iluCurImage->Data[i] = (ILubyte)(Table[iluCurImage->Data[i]] * UCHAR_MAX);
}
break;
case 2:
NumPix = iluCurImage->SizeOfData / 2;
ShortPtr = (ILushort*)iluCurImage->Data;
for (i = 0; i < NumPix; i++) {
ShortPtr[i] = (ILushort)(Table[ShortPtr[i] >> 8] * USHRT_MAX);
}
break;
case 4:
NumPix = iluCurImage->SizeOfData / 4;
IntPtr = (ILuint*)iluCurImage->Data;
for (i = 0; i < NumPix; i++) {
IntPtr[i] = (ILuint)(Table[IntPtr[i] >> 24] * UINT_MAX);
}
break;
}
}
return IL_TRUE;
}
//! Funny as hell filter that I stumbled upon accidentally
ILboolean ILAPIENTRY iluAlienify(ILvoid)
{
ILfloat Mat[3][3];
ILubyte *Data;
ILuint i;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
Data = iluCurImage->Data;
iIdentity((ILfloat*)Mat);
switch (iluCurImage->Format)
{
case IL_BGR:
case IL_BGRA:
for (i = 0; i < iluCurImage->SizeOfData; i += iluCurImage->Bpp) {
Data[i+2] = (ILubyte)(Data[i] * Mat[0][0] + Data[i+1] * Mat[1][0] +
Data[i+2] * Mat[2][0]);// + Mat[3][0]);
Data[i+1] = (ILubyte)(Data[i] * Mat[0][1] + Data[i+1] * Mat[1][1] +
Data[i+2] * Mat[2][1]);// + Mat[3][1]);
Data[i] = (ILubyte)(Data[i] * Mat[0][2] + Data[i+1] * Mat[1][2] +
Data[i+2] * Mat[2][2]);// + Mat[3][2]);
}
break;
case IL_RGB:
case IL_RGBA:
for (i = 0; i < iluCurImage->SizeOfData; i += iluCurImage->Bpp) {
Data[i] = (ILubyte)(Data[i] * Mat[0][2] + Data[i+1] * Mat[1][2] +
Data[i+2] * Mat[2][2]);// + Mat[3][2]);
Data[i+1] = (ILubyte)(Data[i] * Mat[0][1] + Data[i+1] * Mat[1][1] +
Data[i+2] * Mat[2][1]);// + Mat[3][1]);
Data[i+2] = (ILubyte)(Data[i] * Mat[0][0] + Data[i+1] * Mat[1][0] +
Data[i+2] * Mat[2][0]);// + Mat[3][0]);
}
break;
default:
//ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
return IL_TRUE;
}
//! Enlarges the canvas
ILboolean ILAPIENTRY iluEnlargeCanvas(ILuint Width, ILuint Height, ILuint Depth)
{
ILubyte *Data/*, Clear[4]*/;
ILuint x, y, z, OldBps, OldH, OldD, OldPlane, AddX, AddY;
ILenum Origin;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
// Uh-oh, what about 0 dimensions?!
if (Width < iluCurImage->Width || Height < iluCurImage->Height || Depth < iluCurImage->Depth) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iluCurImage->Origin == IL_ORIGIN_LOWER_LEFT) {
switch (iluPlacement)
{
case ILU_LOWER_LEFT:
AddX = 0;
AddY = 0;
break;
case ILU_LOWER_RIGHT:
AddX = Width - iluCurImage->Width;
AddY = 0;
break;
case ILU_UPPER_LEFT:
AddX = 0;
AddY = Height - iluCurImage->Height;
break;
case ILU_UPPER_RIGHT:
AddX = Width - iluCurImage->Width;
AddY = Height - iluCurImage->Height;
break;
case ILU_CENTER:
AddX = (Width - iluCurImage->Width) >> 1;
AddY = (Height - iluCurImage->Height) >> 1;
break;
default:
ilSetError(ILU_INVALID_PARAM);
return IL_FALSE;
}
}
else { // IL_ORIGIN_UPPER_LEFT
switch (iluPlacement)
// Note: No longer changes all textures to powers of 2.
ILboolean ILAPIENTRY iluBuildMipmaps()
{
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
il2SetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
// Get rid of any existing mipmaps.
if (iluCurImage->Mipmaps) {
ilCloseImage(iluCurImage->Mipmaps);
iluCurImage->Mipmaps = NULL;
}
return iBuildMipmaps(iluCurImage, iluCurImage->Width >> 1, iluCurImage->Height >> 1, iluCurImage->Depth >> 1);
}
ILboolean iluCrop3D(ILuint XOff, ILuint YOff, ILuint ZOff, ILuint Width, ILuint Height, ILuint Depth)
{
ILuint x, y, z, c, OldBps, OldPlane;
ILubyte *Data;
ILenum Origin;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
// Uh-oh, what about 0 dimensions?!
if (Width > iluCurImage->Width || Height > iluCurImage->Height || Depth > iluCurImage->Depth) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
Data = (ILubyte*)ialloc(iluCurImage->SizeOfData);
if (Data == NULL) {
return IL_FALSE;
}
OldBps = iluCurImage->Bps;
OldPlane = iluCurImage->SizeOfPlane;
Origin = iluCurImage->Origin;
ilCopyPixels(0, 0, 0, iluCurImage->Width, iluCurImage->Height, iluCurImage->Depth, iluCurImage->Format, iluCurImage->Type, Data);
if (!ilTexImage(Width - XOff, Height - YOff, Depth - ZOff, iluCurImage->Bpp, iluCurImage->Format, iluCurImage->Type, NULL)) {
ifree(Data);
}
iluCurImage->Origin = Origin;
for (z = 0; z < iluCurImage->Depth; z++) {
for (y = 0; y < iluCurImage->Height; y++) {
for (x = 0; x < iluCurImage->Bps; x += iluCurImage->Bpp) {
for (c = 0; c < iluCurImage->Bpp; c++) {
iluCurImage->Data[z * iluCurImage->SizeOfPlane + y * iluCurImage->Bps + x + c] =
Data[(z + ZOff) * OldPlane + (y + YOff) * OldBps + (x + XOff) + c];
}
}
}
}
ifree(Data);
return IL_TRUE;
}
ILboolean iluCrop2D(ILuint XOff, ILuint YOff, ILuint Width, ILuint Height)
{
ILuint x, y, c, OldBps;
ILubyte *Data;
ILenum Origin;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
// Uh-oh, what about 0 dimensions?!
if (Width > iluCurImage->Width || Height > iluCurImage->Height) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
Data = (ILubyte*)ialloc(iluCurImage->SizeOfData);
if (Data == NULL) {
return IL_FALSE;
}
OldBps = iluCurImage->Bps;
Origin = iluCurImage->Origin;
ilCopyPixels(0, 0, 0, iluCurImage->Width, iluCurImage->Height, 1, iluCurImage->Format, iluCurImage->Type, Data);
if (!ilTexImage(Width, Height, iluCurImage->Depth, iluCurImage->Bpp, iluCurImage->Format, iluCurImage->Type, NULL)) {
free(Data);
return IL_FALSE;
}
iluCurImage->Origin = Origin;
// @TODO: Optimize! (Especially XOff * iluCurImage->Bpp...get rid of it!)
for (y = 0; y < iluCurImage->Height; y++) {
for (x = 0; x < iluCurImage->Bps; x += iluCurImage->Bpp) {
for (c = 0; c < iluCurImage->Bpp; c++) {
iluCurImage->Data[y * iluCurImage->Bps + x + c] =
Data[(y + YOff) * OldBps + x + XOff * iluCurImage->Bpp + c];
}
}
}
ifree(Data);
return IL_TRUE;
}
ILboolean iD3D8CreateMipmaps(IDirect3DTexture8 *Texture, ILimage *Image)
{
D3DLOCKED_RECT Rect;
D3DSURFACE_DESC Desc;
ILuint NumMips, Width, Height, i;
ILimage *CurImage, *MipImage, *Temp;
NumMips = IDirect3DTexture8_GetLevelCount(Texture);
Width = Image->Width;
Height = Image->Height;
CurImage = ilGetCurImage();
MipImage = ilCopyImage_(CurImage);
ilSetCurImage(MipImage);
if (!iluBuildMipmaps()) {
ilCloseImage(MipImage);
ilSetCurImage(CurImage);
return IL_FALSE;
}
ilSetCurImage(CurImage);
Temp = MipImage->Mipmaps;
// Counts the base texture as 1.
for (i = 1; i < NumMips && Temp != NULL; i++) {
if (FAILED(IDirect3DTexture8_LockRect(Texture, i, &Rect, NULL, 0)))
return IL_FALSE;
Width = IL_MAX(1, Width / 2);
Height = IL_MAX(1, Height / 2);
IDirect3DTexture8_GetLevelDesc(Texture, i, &Desc);
if (Desc.Width != Width || Desc.Height != Height) {
IDirect3DTexture8_UnlockRect(Texture, i);
return IL_FALSE;
}
memcpy(Rect.pBits, Temp->Data, Temp->SizeOfData);
IDirect3DTexture8_UnlockRect(Texture, i);
Temp = Temp->Next;
}
ilCloseImage(MipImage);
return IL_TRUE;
}
ILboolean ILAPIENTRY iluRotate3D(ILfloat x, ILfloat y, ILfloat z, ILfloat Angle)
{
ILimage *Temp;
// return IL_FALSE;
iluCurImage = ilGetCurImage();
Temp = iluRotate3D_(iluCurImage, x, y, z, Angle);
if (Temp != NULL) {
ilTexImage(Temp->Width, Temp->Height, Temp->Depth, Temp->Bpp, Temp->Format, Temp->Type, Temp->Data);
iluCurImage->Origin = Temp->Origin;
ilSetPal(&Temp->Pal);
ilCloseImage(Temp);
return IL_TRUE;
}
return IL_FALSE;
}
// Unfinished
ILboolean ILAPIENTRY ilutSDLSurfaceFromBitmap(SDL_Surface *Bitmap)
{
ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (Bitmap == NULL || Bitmap->w == 0 || Bitmap->h == 0) {
ilSetError(ILUT_INVALID_PARAM);
return IL_FALSE;
}
if (!ilTexImage(Bitmap->w, Bitmap->h, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL))
return IL_FALSE;
return IL_TRUE;
}
// Unfinished
ILboolean ILAPIENTRY ilutAllegFromBitmap(BITMAP *Bitmap)
{
ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (Bitmap == NULL || Bitmap->w == 0 || Bitmap->h == 0) {
ilSetError(ILUT_INVALID_PARAM);
return IL_FALSE;
}
if (!ilTexImage(Bitmap->w, Bitmap->h, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL))
return IL_FALSE;
ilutCurImage->Origin = IL_ORIGIN_LOWER_LEFT; // I have no idea.
return IL_TRUE;
}
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;
}
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;
}
IDirect3DTexture8* ILAPIENTRY ilutD3D8Texture(IDirect3DDevice8 *Device)
{
IDirect3DTexture8 *Texture;
D3DLOCKED_RECT Rect;
D3DFORMAT Format;
ILimage *Image;
ILenum DXTCFormat;
ILuint Size;
ILubyte *Buffer;
Image = ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return NULL;
}
if (!FormatsDX8Checked)
CheckFormatsDX8(Device);
if (ilutGetBoolean(ILUT_D3D_USE_DXTC) && FormatsDX8supported[3] && FormatsDX8supported[4] && FormatsDX8supported[5]) {
if (ilutCurImage->DxtcData != NULL && ilutCurImage->DxtcSize != 0) {
Format = D3DGetDXTCNumDX8(ilutCurImage->DxtcFormat);
if (FAILED(IDirect3DDevice8_CreateTexture(Device, ilutCurImage->Width,
ilutCurImage->Height, ilutGetInteger(ILUT_D3D_MIPLEVELS), 0, Format,
ilutGetInteger(ILUT_D3D_POOL), &Texture)))
return NULL;
if (FAILED(IDirect3DTexture8_LockRect(Texture, 0, &Rect, NULL, 0)))
return NULL;
memcpy(Rect.pBits, ilutCurImage->DxtcData, ilutCurImage->DxtcSize);
goto success;
}
if (ilutGetBoolean(ILUT_D3D_GEN_DXTC)) {
DXTCFormat = ilutGetInteger(ILUT_DXTC_FORMAT);
Size = ilGetDXTCData(NULL, 0, DXTCFormat);
if (Size != 0) {
Buffer = (ILubyte*)ialloc(Size);
if (Buffer == NULL)
return NULL;
Size = ilGetDXTCData(Buffer, Size, DXTCFormat);
if (Size == 0) {
ifree(Buffer);
return NULL;
}
Format = D3DGetDXTCNumDX8(DXTCFormat);
if (FAILED(IDirect3DDevice8_CreateTexture(Device, ilutCurImage->Width,
ilutCurImage->Height, ilutGetInteger(ILUT_D3D_MIPLEVELS), 0, Format,
ilutGetInteger(ILUT_D3D_POOL), &Texture))) {
ifree(Buffer);
return NULL;
}
if (FAILED(IDirect3DTexture8_LockRect(Texture, 0, &Rect, NULL, 0))) {
ifree(Buffer);
return NULL;
}
memcpy(Rect.pBits, Buffer, Size);
ifree(Buffer);
goto success;
}
}
}
Image = MakeD3D8Compliant(Device, &Format);
if (Image == NULL) {
if (Image != ilutCurImage)
ilCloseImage(Image);
return NULL;
}
if (FAILED(IDirect3DDevice8_CreateTexture(Device, Image->Width, Image->Height,
ilutGetInteger(ILUT_D3D_MIPLEVELS), 0, Format, ilutGetInteger(ILUT_D3D_POOL), &Texture))) {
if (Image != ilutCurImage)
ilCloseImage(Image);
return NULL;
}
if (FAILED(IDirect3DTexture8_LockRect(Texture, 0, &Rect, NULL, 0)))
return NULL;
memcpy(Rect.pBits, Image->Data, Image->SizeOfPlane);
success:
IDirect3DTexture8_UnlockRect(Texture, 0);
// Just let D3DX filter for us.
//D3DXFilterTexture(Texture, NULL, D3DX_DEFAULT, D3DX_FILTER_BOX);
iD3D8CreateMipmaps(Texture, Image);
if (Image != ilutCurImage)
ilCloseImage(Image);
return Texture;
}
// Very simple right now.
// This will probably use Perlin noise and parameters in the future.
ILboolean ILAPIENTRY iluNoisify(ILclampf Tolerance)
{
ILuint i, j, c, Factor, Factor2, NumPix;
ILint Val;
ILushort *ShortPtr;
ILuint *IntPtr;
ILubyte *RegionMask;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
RegionMask = iScanFill();
// @TODO: Change this to work correctly without time()!
//srand(time(NULL));
NumPix = iluCurImage->SizeOfData / iluCurImage->Bpc;
switch (iluCurImage->Bpc)
{
case 1:
Factor = (ILubyte)(Tolerance * (UCHAR_MAX / 2));
if (Factor == 0)
return IL_TRUE;
Factor2 = Factor + Factor;
for (i = 0, j = 0; i < NumPix; i += iluCurImage->Bpp, j++) {
if (RegionMask) {
if (!RegionMask[j])
continue;
}
Val = (ILint)((ILint)(rand() % Factor2) - Factor);
for (c = 0; c < iluCurImage->Bpp; c++) {
if ((ILint)iluCurImage->Data[i + c] + Val > UCHAR_MAX)
iluCurImage->Data[i + c] = UCHAR_MAX;
else if ((ILint)iluCurImage->Data[i + c] + Val < 0)
iluCurImage->Data[i + c] = 0;
else
iluCurImage->Data[i + c] += Val;
}
}
break;
case 2:
Factor = (ILushort)(Tolerance * (USHRT_MAX / 2));
if (Factor == 0)
return IL_TRUE;
Factor2 = Factor + Factor;
ShortPtr = (ILushort*)iluCurImage->Data;
for (i = 0, j = 0; i < NumPix; i += iluCurImage->Bpp, j++) {
if (RegionMask) {
if (!RegionMask[j])
continue;
}
Val = (ILint)((ILint)(rand() % Factor2) - Factor);
for (c = 0; c < iluCurImage->Bpp; c++) {
if ((ILint)ShortPtr[i + c] + Val > USHRT_MAX)
ShortPtr[i + c] = USHRT_MAX;
else if ((ILint)ShortPtr[i + c] + Val < 0)
ShortPtr[i + c] = 0;
else
ShortPtr[i + c] += Val;
}
}
break;
case 4:
Factor = (ILuint)(Tolerance * (UINT_MAX / 2));
if (Factor == 0)
return IL_TRUE;
Factor2 = Factor + Factor;
IntPtr = (ILuint*)iluCurImage->Data;
for (i = 0, j = 0; i < NumPix; i += iluCurImage->Bpp, j++) {
if (RegionMask) {
if (!RegionMask[j])
continue;
}
Val = (ILint)((ILint)(rand() % Factor2) - Factor);
for (c = 0; c < iluCurImage->Bpp; c++) {
if (IntPtr[i + c] + Val > UINT_MAX)
IntPtr[i + c] = UINT_MAX;
else if ((ILint)IntPtr[i + c] + Val < 0)
IntPtr[i + c] = 0;
else
IntPtr[i + c] += Val;
}
}
break;
}
ifree(RegionMask);
return IL_TRUE;
}
ILboolean iD3D9CreateMipmaps(IDirect3DTexture9 *Texture, ILimage *Image)
{
D3DLOCKED_RECT Rect;
D3DSURFACE_DESC Desc;
ILuint NumMips, Width, Height, i;
ILimage *CurImage, *MipImage, *Temp;
ILenum DXTCFormat;
ILuint Size;
ILubyte *Buffer;
ILboolean useDXTC = IL_FALSE;
NumMips = IDirect3DTexture9_GetLevelCount(Texture);
Width = Image->Width;
Height = Image->Height;
if (NumMips == 1)
return IL_TRUE;
CurImage = ilGetCurImage();
MipImage = Image;
if (MipImage->NumMips != NumMips-1) {
MipImage = ilCopyImage_(Image);
ilSetCurImage(MipImage);
if (!iluBuildMipmaps()) {
ilCloseImage(MipImage);
ilSetCurImage(CurImage);
return IL_FALSE;
}
}
// ilSetCurImage(CurImage);
Temp = MipImage->Mipmaps;
if (ilutGetBoolean(ILUT_D3D_USE_DXTC) && FormatsDX9supported[3] && FormatsDX9supported[4] && FormatsDX9supported[5])
useDXTC = IL_TRUE;
// Counts the base texture as 1.
for (i = 1; i < NumMips && Temp != NULL; i++) {
ilSetCurImage(Temp);
if (FAILED(IDirect3DTexture9_LockRect(Texture, i, &Rect, NULL, 0)))
return IL_FALSE;
Width = IL_MAX(1, Width / 2);
Height = IL_MAX(1, Height / 2);
IDirect3DTexture9_GetLevelDesc(Texture, i, &Desc);
if (Desc.Width != Width || Desc.Height != Height) {
IDirect3DTexture9_UnlockRect(Texture, i);
return IL_FALSE;
}
if (useDXTC) {
if (Temp->DxtcData != NULL && Temp->DxtcSize != 0) {
memcpy(Rect.pBits, Temp->DxtcData, Temp->DxtcSize);
} else if (ilutGetBoolean(ILUT_D3D_GEN_DXTC)) {
DXTCFormat = ilutGetInteger(ILUT_DXTC_FORMAT);
Size = ilGetDXTCData(NULL, 0, DXTCFormat);
if (Size != 0) {
Buffer = (ILubyte*)ialloc(Size);
if (Buffer == NULL) {
IDirect3DTexture9_UnlockRect(Texture, i);
return IL_FALSE;
}
Size = ilGetDXTCData(Buffer, Size, DXTCFormat);
if (Size == 0) {
ifree(Buffer);
IDirect3DTexture9_UnlockRect(Texture, i);
return IL_FALSE;
}
memcpy(Rect.pBits, Buffer, Size);
} else {
IDirect3DTexture9_UnlockRect(Texture, i);
return IL_FALSE;
}
} else {
IDirect3DTexture9_UnlockRect(Texture, i);
return IL_FALSE;
}
} else
memcpy(Rect.pBits, Temp->Data, Temp->SizeOfData);
IDirect3DTexture9_UnlockRect(Texture, i);
Temp = Temp->Next;
}
if (MipImage != Image)
ilCloseImage(MipImage);
ilSetCurImage(CurImage);
return IL_TRUE;
}
ILboolean ILAPIENTRY iluScale(ILuint Width, ILuint Height, ILuint Depth)
{
ILimage *Temp;
ILboolean UsePal;
ILenum PalType;
ILenum Origin;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iluCurImage->Width == Width && iluCurImage->Height == Height && iluCurImage->Depth == Depth)
return IL_TRUE;
if( (iluCurImage->Width<Width) || (iluCurImage->Height<Height) ) // only do special scale if there is some zoom?
{
switch (iluFilter)
{
case ILU_SCALE_BOX:
case ILU_SCALE_TRIANGLE:
case ILU_SCALE_BELL:
case ILU_SCALE_BSPLINE:
case ILU_SCALE_LANCZOS3:
case ILU_SCALE_MITCHELL:
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
// Not supported yet.
if (iluCurImage->Type != IL_UNSIGNED_BYTE ||
iluCurImage->Format == IL_COLOUR_INDEX ||
iluCurImage->Depth > 1) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
if(iluCurImage->Width>Width) // shrink width first
{
Origin = iluCurImage->Origin;
Temp = iluScale_(iluCurImage, Width, iluCurImage->Height, iluCurImage->Depth);
if (Temp != NULL)
{
if( !ilTexImage(Temp->Width, Temp->Height, Temp->Depth, Temp->Bpp, Temp->Format, Temp->Type, Temp->Data ) ) {
ilCloseImage(Temp);
return IL_FALSE;
}
iluCurImage->Origin = Origin;
ilCloseImage(Temp);
}
}
else
if(iluCurImage->Height>Height) // shrink height first
{
Origin = iluCurImage->Origin;
Temp = iluScale_(iluCurImage, iluCurImage->Width, Height, iluCurImage->Depth);
if (Temp != NULL)
{
if( !ilTexImage(Temp->Width, Temp->Height, Temp->Depth, Temp->Bpp, Temp->Format, Temp->Type, Temp->Data) ) {
ilCloseImage(Temp);
return IL_FALSE;
}
iluCurImage->Origin = Origin;
ilCloseImage(Temp);
}
}
return (ILboolean)iluScaleAdvanced(Width, Height, iluFilter);
}
}
Origin = iluCurImage->Origin;
UsePal = (iluCurImage->Format == IL_COLOUR_INDEX);
PalType = iluCurImage->Pal.PalType;
Temp = iluScale_(iluCurImage, Width, Height, Depth);
if (Temp != NULL) {
if( !ilTexImage(Temp->Width, Temp->Height, Temp->Depth, Temp->Bpp, Temp->Format, Temp->Type, Temp->Data) ) {
ilCloseImage(Temp);
return IL_FALSE;
}
iluCurImage->Origin = Origin;
ilCloseImage(Temp);
if (UsePal) {
if (!ilConvertImage(IL_COLOUR_INDEX, IL_UNSIGNED_BYTE))
return IL_FALSE;
ilConvertPal(PalType);
}
return IL_TRUE;
}
return IL_FALSE;
}
// Does not account for converting luminance...
SDL_Surface * ILAPIENTRY ilutConvertToSDLSurface(unsigned int flags)
{
SDL_Surface *Bitmap;
ILuint i = 0, Pad, BppPal;
ILubyte *Dest;
ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return NULL;
}
InitSDL();
// Should be IL_BGR(A).
if (ilutCurImage->Format == IL_RGB || ilutCurImage->Format == IL_RGBA) {
if (!isBigEndian)
iluSwapColours();
}
if (ilutCurImage->Origin == IL_ORIGIN_LOWER_LEFT)
iluFlipImage();
if (ilutCurImage->Type > IL_UNSIGNED_BYTE) {} // Can't do anything about this right now...
if (ilutCurImage->Type == IL_BYTE) {} // Can't do anything about this right now...
Bitmap = SDL_CreateRGBSurface(flags,ilutCurImage->Width,ilutCurImage->Height,ilutCurImage->Bpp * 8,
rmask,gmask,bmask,amask);
if (Bitmap == NULL) {
return IL_FALSE;
}
if (SDL_MUSTLOCK(Bitmap))
SDL_LockSurface(Bitmap);
Pad = Bitmap->pitch - ilutCurImage->Bps;
if (Pad == 0) {
memcpy(Bitmap->pixels, ilutCurImage->Data, ilutCurImage->SizeOfData);
}
else { // Must pad the lines on some images.
Dest = Bitmap->pixels;
for (i = 0; i < ilutCurImage->Height; i++) {
memcpy(Dest, ilutCurImage->Data + i * ilutCurImage->Bps, ilutCurImage->Bps);
imemclear(Dest + ilutCurImage->Bps, Pad);
Dest += Bitmap->pitch;
}
}
if (SDL_MUSTLOCK(Bitmap))
SDL_UnlockSurface(Bitmap);
if (ilutCurImage->Bpp == 1) {
BppPal = ilGetBppPal(ilutCurImage->Pal.PalType);
switch (ilutCurImage->Pal.PalType)
{
case IL_PAL_RGB24:
case IL_PAL_RGB32:
case IL_PAL_RGBA32:
for (i = 0; i < ilutCurImage->Pal.PalSize / BppPal; i++) {
(Bitmap->format)->palette->colors[i].r = ilutCurImage->Pal.Palette[i*BppPal+0];
(Bitmap->format)->palette->colors[i].g = ilutCurImage->Pal.Palette[i*BppPal+1];
(Bitmap->format)->palette->colors[i].b = ilutCurImage->Pal.Palette[i*BppPal+2];
(Bitmap->format)->palette->colors[i].unused = 255;
}
break;
case IL_PAL_BGR24:
case IL_PAL_BGR32:
case IL_PAL_BGRA32:
for (i = 0; i < ilutCurImage->Pal.PalSize / BppPal; i++) {
(Bitmap->format)->palette->colors[i].b = ilutCurImage->Pal.Palette[i*BppPal+0];
(Bitmap->format)->palette->colors[i].g = ilutCurImage->Pal.Palette[i*BppPal+1];
(Bitmap->format)->palette->colors[i].r = ilutCurImage->Pal.Palette[i*BppPal+2];
(Bitmap->format)->palette->colors[i].unused = 255;
}
break;
default:
ilSetError(IL_INTERNAL_ERROR); // Do anything else?
}
}
return Bitmap;
}
ILuint iluScaleAdvanced(ILuint Width, ILuint Height, ILenum Filter)
{
double (*f)(double) = filter;
double s = filter_support;
ILimage *Dest;
iluCurImage = ilGetCurImage();
if (iluCurImage == NULL) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
// Not supported yet.
if (iluCurImage->Type != IL_UNSIGNED_BYTE ||
iluCurImage->Format == IL_COLOUR_INDEX ||
iluCurImage->Depth > 1) {
ilSetError(ILU_ILLEGAL_OPERATION);
return IL_FALSE;
}
switch (Filter)
{
case ILU_SCALE_BOX:
f=box_filter;
s=box_support;
break;
case ILU_SCALE_TRIANGLE:
f=triangle_filter;
s=triangle_support;
break;
case ILU_SCALE_BELL:
f=bell_filter;
s=bell_support;
break;
case ILU_SCALE_BSPLINE:
f=B_spline_filter;
s=B_spline_support;
break;
case ILU_SCALE_LANCZOS3:
f=Lanczos3_filter;
s=Lanczos3_support;
break;
case ILU_SCALE_MITCHELL:
f=Mitchell_filter;
s=Mitchell_support;
break;
//case 'h': f=filter; s=filter_support; break;
}
Dest = ilNewImage(Width, Height, 1, iluCurImage->Bpp, 1);
Dest->Origin = iluCurImage->Origin;
Dest->Duration = iluCurImage->Duration;
for (c = 0; c < (ILuint)iluCurImage->Bpp; c++) {
if (zoom(Dest, iluCurImage, f, s) != 0) {
return IL_FALSE;
}
}
ilTexImage(Width, Height, 1, iluCurImage->Bpp, iluCurImage->Format, iluCurImage->Type, Dest->Data);
iluCurImage->Origin = Dest->Origin;
iluCurImage->Duration = Dest->Duration;
ilCloseImage(Dest);
return IL_TRUE;
}
