// Set minimum image size for several images
ILboolean setMinSizes(ILuint w, ILuint h, struct ILimage* img)
{
struct ILimage* currImg = img;
int resizeNeeded = IL_FALSE;
if (img == NULL)
return IL_FALSE;
while (currImg != NULL) {
if (currImg->Width > w)
w = currImg->Width;
else if (w > currImg->Width)
resizeNeeded = IL_TRUE;
if (currImg->Height > h)
h = currImg->Height;
else if (h > currImg->Height)
resizeNeeded = IL_TRUE;
currImg = currImg->Next;
}
if (resizeNeeded) {
ILboolean success = IL_TRUE;
struct ILimage* currImg = img;
while (currImg != NULL && success) {
success &= ilResizeImage(currImg, w, h, 1, 1, 1);
currImg = currImg->Next;
}
return success;
} else
return IL_TRUE;
}
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;
}
ILAPI ILimage* ILAPIENTRY iluRotate_(ILimage *Image, ILfloat Angle)
{
ILimage *Rotated = NULL;
ILuint x, y, c;
ILfloat x0, y0, x1, y1;
ILfloat HalfRotW, HalfRotH, HalfImgW, HalfImgH, Cos, Sin;
ILuint RotOffset, ImgOffset;
ILint XCorner[4], YCorner[4], MaxX, MaxY;
ILushort *ShortPtr;
ILuint *IntPtr;
Rotated = (ILimage*)icalloc(1, sizeof(ILimage));
if (Rotated == NULL)
return NULL;
if (ilCopyImageAttr(Rotated, Image) == IL_FALSE) {
ilCloseImage(Rotated);
return NULL;
}
// Precalculate shit
HalfImgW = Image->Width / 2.0f;
HalfImgH = Image->Height / 2.0f;
Cos = ilCos(Angle);
Sin = ilSin(Angle);
// Find where edges are in new image (origin in center).
XCorner[0] = ilRound(-HalfImgW * Cos - -HalfImgH * Sin);
YCorner[0] = ilRound(-HalfImgW * Sin + -HalfImgH * Cos);
XCorner[1] = ilRound(HalfImgW * Cos - -HalfImgH * Sin);
YCorner[1] = ilRound(HalfImgW * Sin + -HalfImgH * Cos);
XCorner[2] = ilRound(HalfImgW * Cos - HalfImgH * Sin);
YCorner[2] = ilRound(HalfImgW * Sin + HalfImgH * Cos);
XCorner[3] = ilRound(-HalfImgW * Cos - HalfImgH * Sin);
YCorner[3] = ilRound(-HalfImgW * Sin + HalfImgH * Cos);
MaxX = 0; MaxY = 0;
for (x = 0; x < 4; x++) {
if (XCorner[x] > MaxX)
MaxX = XCorner[x];
if (YCorner[x] > MaxY)
MaxY = YCorner[x];
}
if (ilResizeImage(Rotated, MaxX * 2, MaxY * 2, 1, Image->Bpp, Image->Bpc) == IL_FALSE) {
ilCloseImage(Rotated);
return IL_FALSE;
}
HalfRotW = Rotated->Width / 2.0f;
HalfRotH = Rotated->Height / 2.0f;
ilClearImage_(Rotated);
ShortPtr = (ILushort*)iluCurImage->Data;
IntPtr = (ILuint*)iluCurImage->Data;
//if (iluFilter == ILU_NEAREST) {
switch (iluCurImage->Bpc)
{
case 1:
for (y = 0; y < Rotated->Height; y++) {
y0 = y - HalfRotH;
for (x = 0; x < Rotated->Width; x++) {
x0 = x - HalfRotW;
x1 = x0 * Cos - y0 * Sin;
y1 = x0 * Sin + y0 * Cos;
x1 += HalfImgW;
y1 += HalfImgH;
if (x1 < Image->Width && x1 >= 0 && y1 < Image->Height && y1 >= 0) {
RotOffset = y * Rotated->Bps + x * Rotated->Bpp;
ImgOffset = (ILuint)y1 * Image->Bps + (ILuint)x1 * Image->Bpp;
for (c = 0; c < Image->Bpp; c++) {
Rotated->Data[RotOffset + c] = Image->Data[ImgOffset + c];
}
}
}
}
break;
case 2:
Image->Bps /= 2;
Rotated->Bps /= 2;
for (y = 0; y < Rotated->Height; y++) {
y0 = y - HalfRotH;
for (x = 0; x < Rotated->Width; x++) {
x0 = x - HalfRotW;
x1 = x0 * Cos - y0 * Sin;
y1 = x0 * Sin + y0 * Cos;
x1 += HalfImgW;
y1 += HalfImgH;
if (x1 < Image->Width && x1 >= 0 && y1 < Image->Height && y1 >= 0) {
RotOffset = y * Rotated->Bps + x * Rotated->Bpp;
ImgOffset = (ILuint)y1 * Image->Bps + (ILuint)x1 * Image->Bpp;
for (c = 0; c < Image->Bpp; c++) {
((ILushort*)(Rotated->Data))[RotOffset + c] = ShortPtr[ImgOffset + c];
}
}
}
}
Image->Bps *= 2;
Rotated->Bps *= 2;
break;
case 4:
Image->Bps /= 4;
Rotated->Bps /= 4;
for (y = 0; y < Rotated->Height; y++) {
y0 = y - HalfRotH;
for (x = 0; x < Rotated->Width; x++) {
x0 = x - HalfRotW;
x1 = x0 * Cos - y0 * Sin;
y1 = x0 * Sin + y0 * Cos;
x1 += HalfImgW;
y1 += HalfImgH;
if (x1 < Image->Width && x1 >= 0 && y1 < Image->Height && y1 >= 0) {
RotOffset = y * Rotated->Bps + x * Rotated->Bpp;
ImgOffset = (ILuint)y1 * Image->Bps + (ILuint)x1 * Image->Bpp;
for (c = 0; c < Image->Bpp; c++) {
((ILuint*)(Rotated->Data))[RotOffset + c] = IntPtr[ImgOffset + c];
}
}
}
}
Image->Bps *= 4;
Rotated->Bps *= 4;
break;
}
//}
return Rotated;
}
