Category

Development Platform
Home > SourceCode/Document > Compress-Decompress algrithms > View Code
il_devil.c
Package: devil-1.7.99.tar.gz　[view]
Upload User: wmy0603
Upload Date: 2022-05-02
Package Size: 1808k
Code Size: 27k
Category:

Compress-Decompress algrithms

Development Platform:

Visual C++

il_devil.c：Code Content
  1. //-----------------------------------------------------------------------------
  2. //
  3. // ImageLib Sources
  4. // Copyright (C) 2000-2009 by Denton Woods
  5. // Last modified: 02/01/2009
  6. //
  7. // Filename: src-IL/src/il_devil.c
  8. //
  9. // Description: Functions for working with the ILimage's and the current image
  10. //
  11. //-----------------------------------------------------------------------------
  14. #include "il_internal.h"
  15. #include <string.h>
  16. #include <limits.h>
  17. #include "il_manip.h"
  20. ILAPI ILboolean ILAPIENTRY ilInitImage(ILimage *Image, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, void *Data)
  21. {
  22. ILubyte BpcType = ilGetBpcType(Type);
  23. if (BpcType == 0) {
  24. ilSetError(IL_INVALID_PARAM);
  25. return IL_FALSE;
  26. }
  28. memset(Image, 0, sizeof(ILimage));
  30. ////
  31. if (Width  == 0) Width = 1;
  32. if (Height == 0) Height = 1;
  33. if (Depth  == 0) Depth = 1;
  34. Image->Width    = Width;
  35. Image->Height    = Height;
  36. Image->Depth    = Depth;
  37. Image->Bpp    = Bpp;
  38. Image->Bpc    = BpcType;
  39. Image->Bps    = Width * Bpp * Image->Bpc;
  40. Image->SizeOfPlane = Image->Bps * Height;
  41. Image->SizeOfData  = Image->SizeOfPlane * Depth;
  42. Image->Format    = Format;
  43. Image->Type     = Type;
  44. Image->Origin    = IL_ORIGIN_LOWER_LEFT;
  45. Image->Pal.PalType = IL_PAL_NONE;
  46. Image->DxtcFormat  = IL_DXT_NO_COMP;
  47. Image->DxtcData    = NULL;
  49. Image->Data = (ILubyte*)ialloc(Image->SizeOfData);
  50. if (Image->Data == NULL) {
  51. return IL_FALSE;
  52. }
  54. if (Data != NULL) {
  55. memcpy(Image->Data, Data, Image->SizeOfData);
  56. }
  58. return IL_TRUE;
  59. }
  63. // Creates a new ILimage based on the specifications given
  64. ILAPI ILimage* ILAPIENTRY ilNewImage(ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILubyte Bpc)
  65. {
  66. ILimage *Image;
  68. if (Bpp == 0 || Bpp > 4) {
  69. return NULL;
  70. }
  72. Image = (ILimage*)ialloc(sizeof(ILimage));
  73. if (Image == NULL) {
  74. return NULL;
  75. }
  77. if (!ilInitImage(Image, Width, Height, Depth, Bpp, ilGetFormatBpp(Bpp), ilGetTypeBpc(Bpc), NULL)) {
  78. if (Image->Data != NULL) {
  79. ifree(Image->Data);
  80. }
  81. ifree(Image);
  82. return NULL;
  83. }
  85. return Image;
  86. }
  89. // Same as above but allows specification of Format and Type
  90. ILAPI ILimage* ILAPIENTRY ilNewImageFull(ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, void *Data)
  91. {
  92. ILimage *Image;
  94. if (Bpp == 0 || Bpp > 4) {
  95. return NULL;
  96. }
  98. Image = (ILimage*)ialloc(sizeof(ILimage));
  99. if (Image == NULL) {
  100. return NULL;
  101. }
  103. if (!ilInitImage(Image, Width, Height, Depth, Bpp, Format, Type, Data)) {
  104. if (Image->Data != NULL) {
  105. ifree(Image->Data);
  106. }
  107. ifree(Image);
  108. return NULL;
  109. }
  111. return Image;
  112. }
  115. //! Changes the current bound image to use these new dimensions (current data is destroyed).
  116. /*! param Width Specifies the new image width.  This cannot be 0.
  117. param Height Specifies the new image height.  This cannot be 0.
  118. param Depth Specifies the new image depth.  This cannot be 0.
  119. param Bpp Number of channels (ex. 3 for RGB)
  120. param Format Enum of the desired format.  Any format values are accepted.
  121. param Type Enum of the desired type.  Any type values are accepted.
  122. param Data Specifies data that should be copied to the new image. If this parameter is NULL, no data is copied, and the new image data consists of undefined values.
  123. exception IL_ILLEGAL_OPERATION No currently bound image.
  124. exception IL_INVALID_PARAM One of the parameters is incorrect, such as one of the dimensions being 0.
  125. exception IL_OUT_OF_MEMORY Could not allocate enough memory.
  126. return Boolean value of failure or success*/
  127. ILboolean ILAPIENTRY ilTexImage(ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, void *Data)
  128. {
  129. return ilTexImage_(iCurImage, Width, Height, Depth, Bpp, Format, Type, Data);
  130. }
  133. // Internal version of ilTexImage.
  134. ILAPI ILboolean ILAPIENTRY ilTexImage_(ILimage *Image, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, void *Data)
  135. {
  136. if (Image == NULL) {
  137. ilSetError(IL_ILLEGAL_OPERATION);
  138. return IL_FALSE;
  139. }
  141. ////
  143. // Not sure if we should be getting rid of the palette...
  144. if (Image->Pal.Palette && Image->Pal.PalSize && Image->Pal.PalType != IL_PAL_NONE) {
  145. ifree(Image->Pal.Palette);
  146. }
  148. ilCloseImage(Image->Mipmaps);
  149. ilCloseImage(Image->Next);
  150. ilCloseImage(Image->Faces);
  151. ilCloseImage(Image->Layers);
  153. if (Image->AnimList) ifree(Image->AnimList);
  154. if (Image->Profile)  ifree(Image->Profile);
  155. if (Image->DxtcData) ifree(Image->DxtcData);
  156. if (Image->Data)  ifree(Image->Data);
  158. ////
  160. //@TODO: Also check against format?
  161. /*if (Width == 0 || Height == 0 || Depth == 0 || Bpp == 0) {
  162. ilSetError(IL_INVALID_PARAM);
  163. return IL_FALSE;
  164. }*/
  166. return ilInitImage(Image, Width, Height, Depth, Bpp, Format, Type, Data);
  167. }
  170. //! Uploads Data of the same size to replace the current image's data.
  171. /*! param Data New image data to update the currently bound image
  172. exception IL_ILLEGAL_OPERATION No currently bound image
  173. exception IL_INVALID_PARAM Data was NULL.
  174. return Boolean value of failure or success
  175. */
  176. ILboolean ILAPIENTRY ilSetData(void *Data)
  177. {
  178. if (iCurImage == NULL) {
  179. ilSetError(IL_ILLEGAL_OPERATION);
  180. return IL_FALSE;
  181. }
  183. return ilTexSubImage_(iCurImage, Data);
  184. }
  187. // Internal version of ilTexSubImage.
  188. ILAPI ILboolean ILAPIENTRY ilTexSubImage_(ILimage *Image, void *Data)
  189. {
  190. if (Image == NULL || Data == NULL) {
  191. ilSetError(IL_INVALID_PARAM);
  192. return IL_FALSE;
  193. }
  194. if (!Image->Data) {
  195. Image->Data = (ILubyte*)ialloc(Image->SizeOfData);
  196. if (Image->Data == NULL)
  197. return IL_FALSE;
  198. }
  199. memcpy(Image->Data, Data, Image->SizeOfData);
  200. return IL_TRUE;
  201. }
  204. //! Returns a pointer to the current image's data.
  205. /*! The pointer to the image data returned by this function is only valid until any
  206.     operations are done on the image.  After any operations, this function should be
  207. called again.  The pointer can be cast to other types for images that have more
  208. than one byte per channel for easier access to data.
  209. exception IL_ILLEGAL_OPERATION No currently bound image
  210. return ILubyte pointer to image data.*/
  211. ILubyte* ILAPIENTRY ilGetData(void)
  212. {
  213. if (iCurImage == NULL) {
  214. ilSetError(IL_ILLEGAL_OPERATION);
  215. return NULL;
  216. }
  218. return iCurImage->Data;
  219. }
  222. //! Returns a pointer to the current image's palette data.
  223. /*! The pointer to the image palette data returned by this function is only valid until
  224. any operations are done on the image.  After any operations, this function should be
  225. called again.
  226. exception IL_ILLEGAL_OPERATION No currently bound image
  227. return ILubyte pointer to image palette data.*/
  228. ILubyte* ILAPIENTRY ilGetPalette(void)
  229. {
  230. if (iCurImage == NULL) {
  231. ilSetError(IL_ILLEGAL_OPERATION);
  232. return NULL;
  233. }
  235. return iCurImage->Pal.Palette;
  236. }
  239. //ILfloat ClearRed = 0.0f, ClearGreen = 0.0f, ClearBlue = 0.0f, ClearAlpha = 0.0f;
  241. // Changed to the colour of the Universe
  242. // (http://www.newscientist.com/news/news.jsp?id=ns99991775)
  243. // *(http://www.space.com/scienceastronomy/universe_color_020308.html)*
  244. //ILfloat ClearRed = 0.269f, ClearGreen = 0.388f, ClearBlue = 0.342f, ClearAlpha = 0.0f;
  245. static ILfloat ClearRed   = 1.0f;
  246. static ILfloat ClearGreen = 0.972549f;
  247. static ILfloat ClearBlue  = 0.90588f;
  248. static ILfloat ClearAlpha = 0.0f;
  249. static ILfloat ClearLum   = 1.0f;
  251. void ILAPIENTRY ilClearColour(ILclampf Red, ILclampf Green, ILclampf Blue, ILclampf Alpha)
  252. {
  253. // Clamp to 0.0f - 1.0f.
  254. ClearRed = Red < 0.0f ? 0.0f : (Red > 1.0f ? 1.0f : Red);
  255. ClearGreen = Green < 0.0f ? 0.0f : (Green > 1.0f ? 1.0f : Green);
  256. ClearBlue = Blue < 0.0f ? 0.0f : (Blue > 1.0f ? 1.0f : Blue);
  257. ClearAlpha = Alpha < 0.0f ? 0.0f : (Alpha > 1.0f ? 1.0f : Alpha);
  259. if ((Red == Green) && (Red == Blue) && (Green == Blue)) {
  260. ClearLum = Red < 0.0f ? 0.0f : (Red > 1.0f ? 1.0f : Red);
  261. }
  262. else {
  263. ClearLum = 0.212671f * ClearRed + 0.715160f * ClearGreen + 0.072169f * ClearBlue;
  264. ClearLum = ClearLum < 0.0f ? 0.0f : (ClearLum > 1.0f ? 1.0f : ClearLum);
  265. }
  267. return;
  268. }
  271. ILAPI void ILAPIENTRY ilGetClear(void *Colours, ILenum Format, ILenum Type)
  272. {
  273. ILubyte  *BytePtr;
  274. ILushort *ShortPtr;
  275. ILuint *IntPtr;
  276. ILfloat  *FloatPtr;
  277. ILdouble *DblPtr;
  279. switch (Type)
  280. {
  281. case IL_BYTE:
  282. case IL_UNSIGNED_BYTE:
  283. BytePtr = (ILubyte*)Colours;
  284. switch (Format)
  285. {
  286. case IL_RGB:
  287. BytePtr[0] = (ILubyte)(ClearRed * UCHAR_MAX);
  288. BytePtr[1] = (ILubyte)(ClearGreen * UCHAR_MAX);
  289. BytePtr[2] = (ILubyte)(ClearBlue * UCHAR_MAX);
  290. break;
  292. case IL_RGBA:
  293. BytePtr[0] = (ILubyte)(ClearRed * UCHAR_MAX);
  294. BytePtr[1] = (ILubyte)(ClearGreen * UCHAR_MAX);
  295. BytePtr[2] = (ILubyte)(ClearBlue * UCHAR_MAX);
  296. BytePtr[3] = (ILubyte)(ClearAlpha * UCHAR_MAX);
  297. break;
  299. case IL_BGR:
  300. BytePtr[2] = (ILubyte)(ClearRed * UCHAR_MAX);
  301. BytePtr[1] = (ILubyte)(ClearGreen * UCHAR_MAX);
  302. BytePtr[0] = (ILubyte)(ClearBlue * UCHAR_MAX);
  303. BytePtr[3] = (ILubyte)(ClearAlpha * UCHAR_MAX);
  304. break;
  306. case IL_BGRA:
  307. BytePtr[2] = (ILubyte)(ClearRed * UCHAR_MAX);
  308. BytePtr[1] = (ILubyte)(ClearGreen * UCHAR_MAX);
  309. BytePtr[0] = (ILubyte)(ClearBlue * UCHAR_MAX);
  310. BytePtr[3] = (ILubyte)(ClearAlpha * UCHAR_MAX);
  311. break;
  313. case IL_LUMINANCE:
  314. BytePtr[0] = (ILubyte)(ClearAlpha * UCHAR_MAX);
  315. break;
  317. case IL_LUMINANCE_ALPHA:
  318. BytePtr[0] = (ILubyte)(ClearLum * UCHAR_MAX);
  319. BytePtr[1] = (ILubyte)(ClearAlpha * UCHAR_MAX);
  321. case IL_COLOUR_INDEX:
  322. BytePtr[0] = (ILubyte)(ClearAlpha * UCHAR_MAX);
  323. break;
  325. default:
  326. ilSetError(IL_INTERNAL_ERROR);
  327. return;
  328. }
  329. break;
  331. case IL_SHORT:
  332. case IL_UNSIGNED_SHORT:
  333. ShortPtr = (ILushort*)Colours;
  334. switch (Format)
  335. {
  336. case IL_RGB:
  337. ShortPtr[0] = (ILushort)(ClearRed * USHRT_MAX);
  338. ShortPtr[1] = (ILushort)(ClearGreen * USHRT_MAX);
  339. ShortPtr[2] = (ILushort)(ClearBlue * USHRT_MAX);
  340. break;
  342. case IL_RGBA:
  343. ShortPtr[0] = (ILushort)(ClearRed * USHRT_MAX);
  344. ShortPtr[1] = (ILushort)(ClearGreen * USHRT_MAX);
  345. ShortPtr[2] = (ILushort)(ClearBlue * USHRT_MAX);
  346. ShortPtr[3] = (ILushort)(ClearAlpha * USHRT_MAX);
  347. break;
  349. case IL_BGR:
  350. ShortPtr[2] = (ILushort)(ClearRed * USHRT_MAX);
  351. ShortPtr[1] = (ILushort)(ClearGreen * USHRT_MAX);
  352. ShortPtr[0] = (ILushort)(ClearBlue * USHRT_MAX);
  353. ShortPtr[3] = (ILushort)(ClearAlpha * USHRT_MAX);
  354. break;
  356. case IL_BGRA:
  357. ShortPtr[2] = (ILushort)(ClearRed * USHRT_MAX);
  358. ShortPtr[1] = (ILushort)(ClearGreen * USHRT_MAX);
  359. ShortPtr[0] = (ILushort)(ClearBlue * USHRT_MAX);
  360. ShortPtr[3] = (ILushort)(ClearAlpha * USHRT_MAX);
  361. break;
  363. case IL_LUMINANCE:
  364. ShortPtr[0] = (ILushort)(ClearAlpha * USHRT_MAX);
  365. break;
  367. case IL_LUMINANCE_ALPHA:
  368. ShortPtr[0] = (ILushort)(ClearLum * USHRT_MAX);
  369. ShortPtr[1] = (ILushort)(ClearAlpha * USHRT_MAX);
  370. break;
  372. case IL_COLOUR_INDEX:
  373. ShortPtr[0] = (ILushort)(ClearAlpha * USHRT_MAX);
  374. break;
  376. default:
  377. ilSetError(IL_INTERNAL_ERROR);
  378. return;
  379. }
  380. break;
  382. case IL_INT:
  383. case IL_UNSIGNED_INT:
  384. IntPtr = (ILuint*)Colours;
  385. switch (Format)
  386. {
  387. case IL_RGB:
  388. IntPtr[0] = (ILuint)(ClearRed * UINT_MAX);
  389. IntPtr[1] = (ILuint)(ClearGreen * UINT_MAX);
  390. IntPtr[2] = (ILuint)(ClearBlue * UINT_MAX);
  391. break;
  393. case IL_RGBA:
  394. IntPtr[0] = (ILuint)(ClearRed * UINT_MAX);
  395. IntPtr[1] = (ILuint)(ClearGreen * UINT_MAX);
  396. IntPtr[2] = (ILuint)(ClearBlue * UINT_MAX);
  397. IntPtr[3] = (ILuint)(ClearAlpha * UINT_MAX);
  398. break;
  400. case IL_BGR:
  401. IntPtr[2] = (ILuint)(ClearRed * UINT_MAX);
  402. IntPtr[1] = (ILuint)(ClearGreen * UINT_MAX);
  403. IntPtr[0] = (ILuint)(ClearBlue * UINT_MAX);
  404. IntPtr[3] = (ILuint)(ClearAlpha * UINT_MAX);
  405. break;
  407. case IL_BGRA:
  408. IntPtr[2] = (ILuint)(ClearRed * UINT_MAX);
  409. IntPtr[1] = (ILuint)(ClearGreen * UINT_MAX);
  410. IntPtr[0] = (ILuint)(ClearBlue * UINT_MAX);
  411. IntPtr[3] = (ILuint)(ClearAlpha * UINT_MAX);
  412. break;
  414. case IL_LUMINANCE:
  415. IntPtr[0] = (ILuint)(ClearAlpha * UINT_MAX);
  416. break;
  418. case IL_LUMINANCE_ALPHA:
  419. IntPtr[0] = (ILuint)(ClearLum * UINT_MAX);
  420. IntPtr[1] = (ILuint)(ClearAlpha * UINT_MAX);
  421. break;
  423. case IL_COLOUR_INDEX:
  424. IntPtr[0] = (ILuint)(ClearAlpha * UINT_MAX);
  425. break;
  427. default:
  428. ilSetError(IL_INTERNAL_ERROR);
  429. return;
  430. }
  431. break;
  433. case IL_FLOAT:
  434. FloatPtr = (ILfloat*)Colours;
  435. switch (Format)
  436. {
  437. case IL_RGB:
  438. FloatPtr[0] = ClearRed;
  439. FloatPtr[1] = ClearGreen;
  440. FloatPtr[2] = ClearBlue;
  441. break;
  443. case IL_RGBA:
  444. FloatPtr[0] = ClearRed;
  445. FloatPtr[1] = ClearGreen;
  446. FloatPtr[2] = ClearBlue;
  447. FloatPtr[3] = ClearAlpha;
  448. break;
  450. case IL_BGR:
  451. FloatPtr[2] = ClearRed;
  452. FloatPtr[1] = ClearGreen;
  453. FloatPtr[0] = ClearBlue;
  454. FloatPtr[3] = ClearAlpha;
  455. break;
  457. case IL_BGRA:
  458. FloatPtr[2] = ClearRed;
  459. FloatPtr[1] = ClearGreen;
  460. FloatPtr[0] = ClearBlue;
  461. FloatPtr[3] = ClearAlpha;
  462. break;
  464. case IL_LUMINANCE:
  465. FloatPtr[0] = ClearAlpha;
  466. break;
  468. case IL_LUMINANCE_ALPHA:
  469. FloatPtr[0] = ClearLum;
  470. FloatPtr[0] = ClearAlpha;
  471. break;
  473. case IL_COLOUR_INDEX:
  474. FloatPtr[0] = ClearAlpha;
  475. break;
  477. default:
  478. ilSetError(IL_INTERNAL_ERROR);
  479. return;
  480. }
  481. break;
  483. case IL_DOUBLE:
  484. DblPtr = (ILdouble*)Colours;
  485. switch (Format)
  486. {
  487. case IL_RGB:
  488. DblPtr[0] = ClearRed;
  489. DblPtr[1] = ClearGreen;
  490. DblPtr[2] = ClearBlue;
  491. break;
  493. case IL_RGBA:
  494. DblPtr[0] = ClearRed;
  495. DblPtr[1] = ClearGreen;
  496. DblPtr[2] = ClearBlue;
  497. DblPtr[3] = ClearAlpha;
  498. break;
  500. case IL_BGR:
  501. DblPtr[2] = ClearRed;
  502. DblPtr[1] = ClearGreen;
  503. DblPtr[0] = ClearBlue;
  504. DblPtr[3] = ClearAlpha;
  505. break;
  507. case IL_BGRA:
  508. DblPtr[2] = ClearRed;
  509. DblPtr[1] = ClearGreen;
  510. DblPtr[0] = ClearBlue;
  511. DblPtr[3] = ClearAlpha;
  512. break;
  514. case IL_LUMINANCE:
  515. DblPtr[0] = ClearAlpha;
  516. break;
  518. case IL_LUMINANCE_ALPHA:
  519. DblPtr[0] = ClearLum;
  520. DblPtr[1] = ClearAlpha;
  521. break;
  523. case IL_COLOUR_INDEX:
  524. DblPtr[0] = ClearAlpha;
  525. break;
  527. default:
  528. ilSetError(IL_INTERNAL_ERROR);
  529. return;
  530. }
  531. break;
  533. default:
  534. ilSetError(IL_INTERNAL_ERROR);
  535. return;
  536. }
  538. return;
  539. }
  542. //! Clears the current bound image to the values specified in ilClearColour
  543. ILboolean ILAPIENTRY ilClearImage()
  544. {
  545. if (iCurImage == NULL) {
  546. ilSetError(IL_ILLEGAL_OPERATION);
  547. return IL_FALSE;
  548. }
  550. return ilClearImage_(iCurImage);
  551. }
  554. ILAPI ILboolean ILAPIENTRY ilClearImage_(ILimage *Image)
  555. {
  556. ILuint i, c, NumBytes;
  557. ILubyte  Colours[32];  // Maximum is sizeof(double) * 4 = 32
  558. ILubyte  *BytePtr;
  559. ILushort *ShortPtr;
  560. ILuint *IntPtr;
  561. ILfloat  *FloatPtr;
  562. ILdouble *DblPtr;
  564. NumBytes = Image->Bpp * Image->Bpc;
  565. ilGetClear(Colours, Image->Format, Image->Type);
  567. if (Image->Format != IL_COLOUR_INDEX) {
  568. switch (Image->Type)
  569. {
  570. case IL_BYTE:
  571. case IL_UNSIGNED_BYTE:
  572. BytePtr = (ILubyte*)Colours;
  573. for (c = 0; c < NumBytes; c += Image->Bpc) {
  574. for (i = c; i < Image->SizeOfData; i += NumBytes) {
  575. Image->Data[i] = BytePtr[c];
  576. }
  577. }
  578. break;
  580. case IL_SHORT:
  581. case IL_UNSIGNED_SHORT:
  582. ShortPtr = (ILushort*)Colours;
  583. for (c = 0; c < NumBytes; c += Image->Bpc) {
  584. for (i = c; i < Image->SizeOfData; i += NumBytes) {
  585. *((ILushort*)(Image->Data + i)) = ShortPtr[c / Image->Bpc];
  586. }
  587. }
  588. break;
  590. case IL_INT:
  591. case IL_UNSIGNED_INT:
  592. IntPtr = (ILuint*)Colours;
  593. for (c = 0; c < NumBytes; c += Image->Bpc) {
  594. for (i = c; i < Image->SizeOfData; i += NumBytes) {
  595. *((ILuint*)(Image->Data + i)) = IntPtr[c / Image->Bpc];
  596. }
  597. }
  598. break;
  600. case IL_FLOAT:
  601. FloatPtr = (ILfloat*)Colours;
  602. for (c = 0; c < NumBytes; c += Image->Bpc) {
  603. for (i = c; i < Image->SizeOfData; i += NumBytes) {
  604. *((ILfloat*)(Image->Data + i)) = FloatPtr[c / Image->Bpc];
  605. }
  606. }
  607. break;
  609. case IL_DOUBLE:
  610. DblPtr = (ILdouble*)Colours;
  611. for (c = 0; c < NumBytes; c += Image->Bpc) {
  612. for (i = c; i < Image->SizeOfData; i += NumBytes) {
  613. *((ILdouble*)(Image->Data + i)) = DblPtr[c / Image->Bpc];
  614. }
  615. }
  616. break;
  617. }
  618. }
  619. else {
  620. imemclear(Image->Data, Image->SizeOfData);
  622. if (Image->Pal.Palette)
  623. ifree(Image->Pal.Palette);
  624. Image->Pal.Palette = (ILubyte*)ialloc(4);
  625. if (Image->Pal.Palette == NULL) {
  626. return IL_FALSE;
  627. }
  629. Image->Pal.PalType = IL_PAL_RGBA32;
  630. Image->Pal.PalSize = 4;
  632. Image->Pal.Palette[0] = Colours[0] * UCHAR_MAX;
  633. Image->Pal.Palette[1] = Colours[1] * UCHAR_MAX;
  634. Image->Pal.Palette[2] = Colours[2] * UCHAR_MAX;
  635. Image->Pal.Palette[3] = Colours[3] * UCHAR_MAX;
  636. }
  638. return IL_TRUE;
  639. }
  642. //! Overlays the image found in Src on top of the current bound image at the coords specified.
  643. ILboolean ILAPIENTRY ilOverlayImage(ILuint Source, ILint XCoord, ILint YCoord, ILint ZCoord)
  644. {
  645. ILuint Width, Height, Depth;
  646. ILuint Dest;
  648. Dest = ilGetCurName();
  649. ilBindImage(Source);
  650. Width = iCurImage->Width;  Height = iCurImage->Height;  Depth = iCurImage->Depth;
  651. ilBindImage(Dest);
  653. return ilBlit(Source, XCoord, YCoord, ZCoord, 0, 0, 0, Width, Height, Depth);
  654. }
  656. //@NEXT DestX,DestY,DestZ must be set to ILuint
  657. ILboolean ILAPIENTRY ilBlit(ILuint Source, ILint DestX,  ILint DestY,   ILint DestZ, 
  658.                                            ILuint SrcX,  ILuint SrcY,   ILuint SrcZ,
  659.                                            ILuint Width, ILuint Height, ILuint Depth)
  660. {
  661. ILuint  x, y, z, ConvBps, ConvSizePlane;
  662. ILimage  *Dest,*Src;
  663. ILubyte  *Converted;
  664. ILuint DestName = ilGetCurName();
  665. ILuint c;
  666. ILuint StartX, StartY, StartZ;
  667. ILboolean DestFlipped = IL_FALSE;
  668. ILubyte  *SrcTemp;
  669. ILfloat Back;
  671. // Check if the desiination image really exists
  672. if (DestName == 0 || iCurImage == NULL) {
  673. ilSetError(IL_ILLEGAL_OPERATION);
  674. return IL_FALSE;
  675. }
  676. Dest = iCurImage;
  678. // set the destination image to upper left origin
  679. if (Dest->Origin == IL_ORIGIN_LOWER_LEFT) {  // Dest
  680. DestFlipped = IL_TRUE;
  681. ilFlipImage();
  682. }
  683. //DestOrigin = Dest->Origin;
  684. ilBindImage(Source);
  686. // Check if the source image really exists
  687. if (iCurImage == NULL) {
  688. ilSetError(IL_INVALID_PARAM);
  689. return IL_FALSE;
  690. }
  692. Src = iCurImage;
  694. //@TODO test if coordinates are inside the images (hard limit for source)
  696. // set the source image to upper left origin
  697. if (Src->Origin == IL_ORIGIN_LOWER_LEFT)
  698. {
  699. SrcTemp = iGetFlipped(iCurImage);
  700. if (SrcTemp == NULL)
  701. {
  702. ilBindImage(DestName);
  703. if (DestFlipped)
  704. ilFlipImage();
  705. return IL_FALSE;
  706. }
  707. }
  708. else
  709. {
  710. SrcTemp = iCurImage->Data;
  711. }
  713. // convert source image to match the destination image type and format
  714. Converted = (ILubyte*)ilConvertBuffer(Src->SizeOfData, Src->Format, Dest->Format, Src->Type, Dest->Type, NULL, SrcTemp);
  715. if (Converted == NULL)
  716. return IL_FALSE;
  718. ConvBps    = Dest->Bpp * Src->Width;
  719. ConvSizePlane = ConvBps   * Src->Height;
  721. //@NEXT in next version this would have to be removed since Dest* will be unsigned
  722. StartX = DestX >= 0 ? 0 : -DestX;
  723. StartY = DestY >= 0 ? 0 : -DestY;
  724. StartZ = DestZ >= 0 ? 0 : -DestZ;
  726. // Limit the copy of data inside of the destination image
  727. if (Width  + DestX > Dest->Width)  Width  = Dest->Width  - DestX;
  728. if (Height + DestY > Dest->Height) Height = Dest->Height - DestY;
  729. if (Depth  + DestZ > Dest->Depth)  Depth  = Dest->Depth  - DestZ;
  731. //@TODO: non funziona con rgba
  732. if (Src->Format == IL_RGBA || Src->Format == IL_BGRA || Src->Format == IL_LUMINANCE_ALPHA) {
  733. const ILuint bpp_without_alpha = Dest->Bpp - 1;
  734. for (z = 0; z < Depth; z++) {
  735. for (y = 0; y < Height; y++) {
  736. for (x = 0; x < Width; x++) {
  737. const ILuint  SrcIndex  = (z+SrcZ)*ConvSizePlane + (y+SrcY)*ConvBps + (x+SrcX)*Dest->Bpp;
  738. const ILuint  DestIndex = (z+DestZ)*Dest->SizeOfPlane + (y+DestY)*Dest->Bps + (x+DestX)*Dest->Bpp;
  739. const ILuint  AlphaIdx = SrcIndex + bpp_without_alpha;
  740. ILfloat Front = 0;
  742. switch (Dest->Type)
  743. {
  744. case IL_BYTE:
  745. case IL_UNSIGNED_BYTE:
  746. Front = Converted[AlphaIdx]/((float)IL_MAX_UNSIGNED_BYTE);
  747. break;
  748. case IL_SHORT:
  749. case IL_UNSIGNED_SHORT:
  750. Front = ((ILshort*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_SHORT);
  751. break;
  752. case IL_INT:
  753. case IL_UNSIGNED_INT:
  754. Front = ((ILint*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_INT);
  755. break;
  756. case IL_FLOAT:
  757. Front = ((ILfloat*)Converted)[AlphaIdx];
  758. break;
  759. case IL_DOUBLE:
  760. Front = (ILfloat)(((ILdouble*)Converted)[AlphaIdx]);
  761. break;
  762. }
  763. Back = 1.0f - Front;
  764. // In case of Alpha channel, the data is blended. Keeps the original alpha.
  765. if (ilIsEnabled(IL_BLIT_BLEND)) {
  766. for (c = 0; c < bpp_without_alpha; c++)
  767. {
  768. Dest->Data[DestIndex + c] = 
  769. (ILubyte)(Converted[SrcIndex + c] * Front
  770. + Dest->Data[DestIndex + c] * Back);
  771. }
  772. }
  773. else {
  774. for (c = 0; c < Dest->Bpp; c++)
  775. {
  776. Dest->Data[DestIndex + c] = (ILubyte)(Converted[SrcIndex + c]);
  777. }
  778. }
  779. }
  780. }
  781. }
  782. } else {
  783. for( z = 0; z < Depth; z++ ) {
  784. for( y = 0; y < Height; y++ ) {
  785. for( x = 0; x < Width; x++ ) {
  786. for( c = 0; c < Dest->Bpp; c++ ) {
  787. Dest->Data[(z+DestZ)*Dest->SizeOfPlane + (y+DestY)*Dest->Bps + (x+DestX)*Dest->Bpp + c] =
  788.  Converted[(z+SrcZ)*ConvSizePlane + (y+SrcY)*ConvBps + (x+SrcX)*Dest->Bpp + c];
  789. }
  790. }
  791. }
  792. }
  793. }
  795. if (SrcTemp != iCurImage->Data)
  796. ifree(SrcTemp);
  798. ilBindImage(DestName);
  799. if (DestFlipped)
  800. ilFlipImage();
  802. ifree(Converted);
  804. return IL_TRUE;
  805. }
  808. ILboolean iCopySubImage(ILimage *Dest, ILimage *Src)
  809. {
  810. ILimage *DestTemp, *SrcTemp;
  812. DestTemp = Dest;
  813. SrcTemp = Src;
  815. do {
  816. ilCopyImageAttr(DestTemp, SrcTemp);
  817. DestTemp->Data = (ILubyte*)ialloc(SrcTemp->SizeOfData);
  818. if (DestTemp->Data == NULL) {
  819. return IL_FALSE;
  820. }
  821. memcpy(DestTemp->Data, SrcTemp->Data, SrcTemp->SizeOfData);
  823. if (SrcTemp->Next) {
  824. DestTemp->Next = (ILimage*)icalloc(1, sizeof(ILimage));
  825. if (!DestTemp->Next) {
  826. return IL_FALSE;
  827. }
  828. }
  829. else {
  830. DestTemp->Next = NULL;
  831. }
  833. DestTemp = DestTemp->Next;
  834. SrcTemp = SrcTemp->Next;
  835. } while (SrcTemp);
  837. return IL_TRUE;
  838. }
  841. ILboolean iCopySubImages(ILimage *Dest, ILimage *Src)
  842. {
  843. if (Src->Faces) {
  844. Dest->Faces = (ILimage*)icalloc(1, sizeof(ILimage));
  845. if (!Dest->Faces) {
  846. return IL_FALSE;
  847. }
  848. if (!iCopySubImage(Dest->Faces, Src->Faces))
  849. return IL_FALSE;
  850. }
  852. if (Src->Layers) {
  853. Dest->Layers = (ILimage*)icalloc(1, sizeof(ILimage));
  854. if (!Dest->Layers) {
  855. return IL_FALSE;
  856. }
  857. if (!iCopySubImage(Dest->Layers, Src->Layers))
  858. return IL_FALSE;
  859. }
  861. if (Src->Mipmaps) {
  862. Dest->Mipmaps = (ILimage*)icalloc(1, sizeof(ILimage));
  863. if (!Dest->Mipmaps) {
  864. return IL_FALSE;
  865. }
  866. if (!iCopySubImage(Dest->Mipmaps, Src->Mipmaps))
  867. return IL_FALSE;
  868. }
  870. if (Src->Next) {
  871. Dest->Next = (ILimage*)icalloc(1, sizeof(ILimage));
  872. if (!Dest->Next) {
  873. return IL_FALSE;
  874. }
  875. if (!iCopySubImage(Dest->Next, Src->Next))
  876. return IL_FALSE;
  877. }
  879. return IL_TRUE;
  880. }
  883. // Copies everything but the Data from Src to Dest.
  884. ILAPI ILboolean ILAPIENTRY ilCopyImageAttr(ILimage *Dest, ILimage *Src)
  885. {
  886. if (Dest == NULL || Src == NULL) {
  887. ilSetError(IL_INVALID_PARAM);
  888. return IL_FALSE;
  889. }
  891. if (Dest->Pal.Palette && Dest->Pal.PalSize && Dest->Pal.PalType != IL_PAL_NONE) {
  892. ifree(Dest->Pal.Palette);
  893. Dest->Pal.Palette = NULL;
  894. }
  895. if (Dest->Faces) {
  896. ilCloseImage(Dest->Faces);
  897. Dest->Faces = NULL;
  898. }
  899. if (Dest->Layers) {
  900. ilCloseImage(Dest->Layers);
  901. Dest->Layers = NULL;
  902. }
  903. if (Dest->Mipmaps) {
  904. ilCloseImage(Dest->Mipmaps);
  905. Dest->Mipmaps = NULL;
  906. }
  907. if (Dest->Next) {
  908. ilCloseImage(Dest->Next);
  909. Dest->Next = NULL;
  910. }
  911. if (Dest->Profile) {
  912. ifree(Dest->Profile);
  913. Dest->Profile = NULL;
  914. Dest->ProfileSize = 0;
  915. }
  916. if (Dest->DxtcData) {
  917. ifree(Dest->DxtcData);
  918. Dest->DxtcData = NULL;
  919. Dest->DxtcFormat = IL_DXT_NO_COMP;
  920. Dest->DxtcSize = 0;
  921. }
  923. if (Src->AnimList && Src->AnimSize) {
  924. Dest->AnimList = (ILuint*)ialloc(Src->AnimSize * sizeof(ILuint));
  925. if (Dest->AnimList == NULL) {
  926. return IL_FALSE;
  927. }
  928. memcpy(Dest->AnimList, Src->AnimList, Src->AnimSize * sizeof(ILuint));
  929. }
  930. if (Src->Profile) {
  931. Dest->Profile = (ILubyte*)ialloc(Src->ProfileSize);
  932. if (Dest->Profile == NULL) {
  933. return IL_FALSE;
  934. }
  935. memcpy(Dest->Profile, Src->Profile, Src->ProfileSize);
  936. Dest->ProfileSize = Src->ProfileSize;
  937. }
  938. if (Src->Pal.Palette) {
  939. Dest->Pal.Palette = (ILubyte*)ialloc(Src->Pal.PalSize);
  940. if (Dest->Pal.Palette == NULL) {
  941. return IL_FALSE;
  942. }
  943. memcpy(Dest->Pal.Palette, Src->Pal.Palette, Src->Pal.PalSize);
  944. }
  945. else {
  946. Dest->Pal.Palette = NULL;
  947. }
  949. Dest->Pal.PalSize = Src->Pal.PalSize;
  950. Dest->Pal.PalType = Src->Pal.PalType;
  951. Dest->Width = Src->Width;
  952. Dest->Height = Src->Height;
  953. Dest->Depth = Src->Depth;
  954. Dest->Bpp = Src->Bpp;
  955. Dest->Bpc = Src->Bpc;
  956. Dest->Bps = Src->Bps;
  957. Dest->SizeOfPlane = Src->SizeOfPlane;
  958. Dest->SizeOfData = Src->SizeOfData;
  959. Dest->Format = Src->Format;
  960. Dest->Type = Src->Type;
  961. Dest->Origin = Src->Origin;
  962. Dest->Duration = Src->Duration;
  963. Dest->CubeFlags = Src->CubeFlags;
  964. Dest->AnimSize = Src->AnimSize;
  965. Dest->OffX = Src->OffX;
  966. Dest->OffY = Src->OffY;
  968. return IL_TRUE/*iCopySubImages(Dest, Src)*/;
  969. }
  972. //! Copies everything from Src to the current bound image.
  973. ILboolean ILAPIENTRY ilCopyImage(ILuint Src)
  974. {
  975. ILuint DestName = ilGetCurName();
  976. ILimage *DestImage = iCurImage, *SrcImage;
  978. if (iCurImage == NULL || DestName == 0) {
  979. ilSetError(IL_ILLEGAL_OPERATION);
  980. return IL_FALSE;
  981. }
  983. ilBindImage(Src);
  984. SrcImage = iCurImage;
  985. ilBindImage(DestName);
  986. ilTexImage(SrcImage->Width, SrcImage->Height, SrcImage->Depth, SrcImage->Bpp, SrcImage->Format, SrcImage->Type, SrcImage->Data);
  987. ilCopyImageAttr(DestImage, SrcImage);
  989. return IL_TRUE;
  990. }
  993. // Creates a copy of Src and returns it.
  994. ILAPI ILimage* ILAPIENTRY ilCopyImage_(ILimage *Src)
  995. {
  996. ILimage *Dest;
  998. if (Src == NULL) {
  999. ilSetError(IL_INVALID_PARAM);
  1000. return NULL;
  1001. }
  1003. Dest = ilNewImage(Src->Width, Src->Height, Src->Depth, Src->Bpp, Src->Bpc);
  1004. if (Dest == NULL) {
  1005. return NULL;
  1006. }
  1008. if (ilCopyImageAttr(Dest, Src) == IL_FALSE)
  1009. return NULL;
  1011. memcpy(Dest->Data, Src->Data, Src->SizeOfData);
  1013. return Dest;
  1014. }
  1017. ILuint ILAPIENTRY ilCloneCurImage()
  1018. {
  1019. ILuint Id;
  1020. ILimage *CurImage;
  1022. if (iCurImage == NULL) {
  1023. ilSetError(IL_ILLEGAL_OPERATION);
  1024. return 0;
  1025. }
  1027. ilGenImages(1, &Id);
  1028. if (Id == 0)
  1029. return 0;
  1031. CurImage = iCurImage;
  1033. ilBindImage(Id);
  1034. ilTexImage(CurImage->Width, CurImage->Height, CurImage->Depth, CurImage->Bpp, CurImage->Format, CurImage->Type, CurImage->Data);
  1035. ilCopyImageAttr(iCurImage, CurImage);
  1037. iCurImage = CurImage;
  1039. return Id;
  1040. }
  1043. // Like ilTexImage but doesn't destroy the palette.
  1044. ILAPI ILboolean ILAPIENTRY ilResizeImage(ILimage *Image, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILubyte Bpc)
  1045. {
  1046. if (Image == NULL) {
  1047. ilSetError(IL_INVALID_PARAM);
  1048. return IL_FALSE;
  1049. }
  1051. if (Image->Data != NULL)
  1052. ifree(Image->Data);
  1054. Image->Depth = Depth;
  1055. Image->Width = Width;
  1056. Image->Height = Height;
  1057. Image->Bpp = Bpp;
  1058. Image->Bpc = Bpc;
  1059. Image->Bps = Bpp * Bpc * Width;
  1060. Image->SizeOfPlane = Image->Bps * Height;
  1061. Image->SizeOfData = Image->SizeOfPlane * Depth;
  1063. Image->Data = (ILubyte*)ialloc(Image->SizeOfData);
  1064. if (Image->Data == NULL) {
  1065. return IL_FALSE;
  1066. }
  1068. return IL_TRUE;
  1069. }