Category

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

Compress-Decompress algrithms

Development Platform:

Visual C++

il_stack.c：Code Content
  1. //-----------------------------------------------------------------------------
  2. //
  3. // ImageLib Sources
  4. // Copyright (C) 2000-2008 by Denton Woods
  5. // Last modified: 12/17/2008
  6. //
  7. // Filename: src-IL/src/il_stack.c
  8. //
  9. // Description: The main image stack
  10. //
  11. //-----------------------------------------------------------------------------
  13. // Credit goes to John Villar (johnny@reliaschev.com) for making the suggestion
  14. // of not letting the user use ILimage structs but instead binding images
  15. // like OpenGL.
  17. #include "il_internal.h"
  18. #include "il_logging.h"
  19. #include "il_stack.h"
  21. //! Creates Num images and puts their index in Images - similar to glGenTextures().
  22. void ILAPIENTRY ilGenImages(ILsizei Num, ILuint *Images)
  23. {
  24. ILsizei Index = 0;
  25. iFree *TempFree = FreeNames;
  27. if (Num < 1 || Images == NULL) {
  28. ilSetError(IL_INVALID_VALUE);
  29. return;
  30. }
  32. // No images have been generated yet, so create the image stack.
  33. if (ImageStack == NULL)
  34. if (!iEnlargeStack())
  35. return;
  37. do {
  38. if (FreeNames != NULL) {  // If any have been deleted, then reuse their image names.
  39.                         TempFree = (iFree*)FreeNames->Next;
  40.                         Images[Index] = FreeNames->Name;
  41.                         ImageStack[FreeNames->Name] = ilNewImage(1, 1, 1, 1, 1);
  42.                         ifree(FreeNames);
  43.                         FreeNames = TempFree;
  44. } else {
  45.                         if (LastUsed >= StackSize)
  46. if (!iEnlargeStack())
  47. return;
  48. Images[Index] = LastUsed;
  49. // Must be all 1's instead of 0's, because some functions would divide by 0.
  50. ImageStack[LastUsed] = ilNewImage(1, 1, 1, 1, 1);
  51. LastUsed++;
  52. }
  53. } while (++Index < Num);
  54. LOG_ADVANCED(IL_LOG_INFO, _("ilGenImages: Generated %u images, the first is %u"), Num, Images[0]);
  55. return;
  56. }
  58. ILuint ILAPIENTRY ilGenImage()
  59. {
  60.     ILuint i;
  61.     ilGenImages(1,&i);
  62.     return i;
  63. }
  65. //! Makes Image the current active image - similar to glBindTexture().
  66. void ILAPIENTRY ilBindImage(ILuint Image)
  67. {
  68. if (ImageStack == NULL || StackSize == 0) {
  69. if (!iEnlargeStack()) {
  70. return;
  71. }
  72. }
  74. // If the user requests a high image name.
  75. while (Image >= StackSize) {
  76. if (!iEnlargeStack()) {
  77. return;
  78. }
  79. }
  81. if (ImageStack[Image] == NULL) {
  82. ImageStack[Image] = ilNewImage(1, 1, 1, 1, 1);
  83. if (Image >= LastUsed) // >= ?
  84. LastUsed = Image + 1;
  85. }
  87. iCurImage = ImageStack[Image];
  88. CurName = Image;
  90. LOG_ADVANCED(IL_LOG_VERBOSE, _("ilBindImage: The current image is now %u"), Image);
  91. ParentImage = IL_TRUE;
  93. return;
  94. }
  97. //! Deletes Num images from the image stack - similar to glDeleteTextures().
  98. void ILAPIENTRY ilDeleteImages(ILsizei Num, const ILuint *Images)
  99. {
  100. iFree *Temp = FreeNames;
  101. ILuint Index = 0;
  103. if (Num < 1) {
  104. //ilSetError(IL_INVALID_VALUE);
  105. return;
  106. }
  107. if (StackSize == 0)
  108. return;
  110. LOG_ADVANCED(IL_LOG_INFO, _("ilDeleteImages: Deleted %u images, the first one was %u"), Num, * Images);
  111. do {
  112. if (Images[Index] > 0 && Images[Index] < LastUsed) {  // <= ?
  113. /*if (FreeNames != NULL) {  // Terribly inefficient
  114. Temp = FreeNames;
  115. do {
  116. if (Temp->Name == Images[Index]) {
  117. continue;  // Sufficient?
  118. }
  119. } while ((Temp = Temp->Next));
  120. }*/
  122. // Already has been deleted or was never used.
  123. if (ImageStack[Images[Index]] == NULL)
  124. continue;
  126. // Find out if current image - if so, set to default image zero.
  127. if (Images[Index] == CurName || Images[Index] == 0) {
  128. iCurImage = ImageStack[0];
  129. CurName = 0;
  130. }
  132. // Should *NOT* be NULL here!
  133. ilCloseImage(ImageStack[Images[Index]]);
  134. ImageStack[Images[Index]] = NULL;
  136. // Add to head of list - works for empty and non-empty lists
  137. Temp = (iFree*)ialloc(sizeof(iFree));
  138. if (!Temp) {
  139. return;
  140. }
  141. Temp->Name = Images[Index];
  142. Temp->Next = FreeNames;
  143. FreeNames = Temp;
  144. }
  145. /*else {  // Shouldn't set an error...just continue onward.
  146. ilSetError(IL_ILLEGAL_OPERATION);
  147. }*/
  148. } while (++Index < (ILuint)Num);
  149. }
  152. void ILAPIENTRY ilDeleteImage(const ILuint Num) {
  153.     ilDeleteImages(1,&Num);
  154. }
  156. //! Checks if Image is a valid ilGenImages-generated image (like glIsTexture()).
  157. ILboolean ILAPIENTRY ilIsImage(ILuint Image)
  158. {
  159. //iFree *Temp = FreeNames;
  161. if (ImageStack == NULL)
  162. return IL_FALSE;
  163. if (Image >= LastUsed || Image == 0)
  164. return IL_FALSE;
  166. /*do {
  167. if (Temp->Name == Image)
  168. return IL_FALSE;
  169. } while ((Temp = Temp->Next));*/
  171. if (ImageStack[Image] == NULL)  // Easier check.
  172. return IL_FALSE;
  174. return IL_TRUE;
  175. }
  178. //! Closes Image and frees all memory associated with it.
  179. ILAPI void ILAPIENTRY ilCloseImage(ILimage *Image)
  180. {
  181. if (Image == NULL)
  182. return;
  184. if (Image->Data != NULL) {
  185. ifree(Image->Data);
  186. Image->Data = NULL;
  187. }
  189. if (Image->Pal.Palette != NULL && Image->Pal.PalSize > 0 && Image->Pal.PalType != IL_PAL_NONE) {
  190. ifree(Image->Pal.Palette);
  191. Image->Pal.Palette = NULL;
  192. }
  194. if (Image->Next != NULL) {
  195. ilCloseImage(Image->Next);
  196. Image->Next = NULL;
  197. }
  199. if (Image->Faces != NULL) {
  200. ilCloseImage(Image->Faces);
  201. Image->Mipmaps = NULL;
  202. }
  204. if (Image->Mipmaps != NULL) {
  205. ilCloseImage(Image->Mipmaps);
  206. Image->Mipmaps = NULL;
  207. }
  209. if (Image->Layers != NULL) {
  210. ilCloseImage(Image->Layers);
  211. Image->Layers = NULL;
  212. }
  214. if (Image->AnimList != NULL && Image->AnimSize != 0) {
  215. ifree(Image->AnimList);
  216. Image->AnimList = NULL;
  217. }
  219. if (Image->Profile != NULL && Image->ProfileSize != 0) {
  220. ifree(Image->Profile);
  221. Image->Profile = NULL;
  222. Image->ProfileSize = 0;
  223. }
  225. if (Image->DxtcData != NULL && Image->DxtcFormat != IL_DXT_NO_COMP) {
  226. ifree(Image->DxtcData);
  227. Image->DxtcData = NULL;
  228. Image->DxtcFormat = IL_DXT_NO_COMP;
  229. Image->DxtcSize = 0;
  230. }
  232. ifree(Image);
  233. Image = NULL;
  235. return;
  236. }
  239. ILAPI ILboolean ILAPIENTRY ilIsValid_PAL(ILpal *Palette)
  240. {
  241. if (Palette == NULL)
  242. return IL_FALSE;
  243. if (Palette->PalSize == 0 || Palette->Palette == NULL)
  244. return IL_FALSE;
  245. switch (Palette->PalType)
  246. {
  247. case IL_PAL_RGB24:
  248. case IL_PAL_RGB32:
  249. case IL_PAL_RGBA32:
  250. case IL_PAL_BGR24:
  251. case IL_PAL_BGR32:
  252. case IL_PAL_BGRA32:
  253. return IL_TRUE;
  254. }
  255. return IL_FALSE;
  256. }
  259. //! Closes Palette and frees all memory associated with it.
  260. ILAPI void ILAPIENTRY ilClosePal(ILpal *Palette)
  261. {
  262. if (Palette == NULL)
  263. return;
  264. if (!ilIsValid_PAL(Palette))
  265. return;
  266. ifree(Palette->Palette);
  267. ifree(Palette);
  268. return;
  269. }
  272. ILimage *iGetBaseImage()
  273. {
  274. return ImageStack[ilGetCurName()];
  275. }
  278. //! Sets the current mipmap level
  279. ILboolean ILAPIENTRY ilActiveMipmap(ILuint Number)
  280. {
  281. ILuint Current;
  282.     ILimage *iTempImage;
  284. if (iCurImage == NULL) {
  285. ilSetError(IL_ILLEGAL_OPERATION);
  286. return IL_FALSE;
  287. }
  289. if (Number == 0) {
  290. return IL_TRUE;
  291. }
  293.     iTempImage = iCurImage;
  294. iCurImage = iCurImage->Mipmaps;
  295. if (iCurImage == NULL) {
  296. iCurImage = iTempImage;
  297. ilSetError(IL_ILLEGAL_OPERATION);
  298. return IL_FALSE;
  299. }
  301. for (Current = 1; Current < Number; Current++) {
  302. iCurImage = iCurImage->Mipmaps;
  303. if (iCurImage == NULL) {
  304. ilSetError(IL_ILLEGAL_OPERATION);
  305. iCurImage = iTempImage;
  306. return IL_FALSE;
  307. }
  308. }
  310. ParentImage = IL_FALSE;
  312. return IL_TRUE;
  313. }
  316. //! Used for setting the current image if it is an animation.
  317. ILboolean ILAPIENTRY ilActiveImage(ILuint Number)
  318. {
  319. ILuint Current;
  320.     ILimage *iTempImage;
  321.     
  322. if (iCurImage == NULL) {
  323. ilSetError(IL_ILLEGAL_OPERATION);
  324. return IL_FALSE;
  325. }
  327. if (Number == 0) {
  328. return IL_TRUE;
  329. }
  331.     iTempImage = iCurImage;
  332. iCurImage = iCurImage->Next;
  333. if (iCurImage == NULL) {
  334. iCurImage = iTempImage;
  335. ilSetError(IL_ILLEGAL_OPERATION);
  336. return IL_FALSE;
  337. }
  339. Number--;  // Skip 0 (parent image)
  340. for (Current = 0; Current < Number; Current++) {
  341. iCurImage = iCurImage->Next;
  342. if (iCurImage == NULL) {
  343. ilSetError(IL_ILLEGAL_OPERATION);
  344. iCurImage = iTempImage;
  345. return IL_FALSE;
  346. }
  347. }
  349. ParentImage = IL_FALSE;
  351. return IL_TRUE;
  352. }
  355. //! Used for setting the current face if it is a cubemap.
  356. ILboolean ILAPIENTRY ilActiveFace(ILuint Number)
  357. {
  358. ILuint Current;
  359.     ILimage *iTempImage;
  361. if (iCurImage == NULL) {
  362. ilSetError(IL_ILLEGAL_OPERATION);
  363. return IL_FALSE;
  364. }
  366. if (Number == 0) {
  367. return IL_TRUE;
  368. }
  370.     iTempImage = iCurImage;
  371. iCurImage = iCurImage->Faces;
  372. if (iCurImage == NULL) {
  373. iCurImage = iTempImage;
  374. ilSetError(IL_ILLEGAL_OPERATION);
  375. return IL_FALSE;
  376. }
  378. //Number--;  // Skip 0 (parent image)
  379. for (Current = 1; Current < Number; Current++) {
  380. iCurImage = iCurImage->Faces;
  381. if (iCurImage == NULL) {
  382. ilSetError(IL_ILLEGAL_OPERATION);
  383. iCurImage = iTempImage;
  384. return IL_FALSE;
  385. }
  386. }
  388. ParentImage = IL_FALSE;
  390. return IL_TRUE;
  391. }
  395. //! Used for setting the current layer if layers exist.
  396. ILboolean ILAPIENTRY ilActiveLayer(ILuint Number)
  397. {
  398. ILuint Current;
  399.     ILimage *iTempImage;
  401. if (iCurImage == NULL) {
  402. ilSetError(IL_ILLEGAL_OPERATION);
  403. return IL_FALSE;
  404. }
  406. if (Number == 0) {
  407. return IL_TRUE;
  408. }
  410.     iTempImage = iCurImage;
  411. iCurImage = iCurImage->Layers;
  412. if (iCurImage == NULL) {
  413. iCurImage = iTempImage;
  414. ilSetError(IL_ILLEGAL_OPERATION);
  415. return IL_FALSE;
  416. }
  418. //Number--;  // Skip 0 (parent image)
  419. for (Current = 1; Current < Number; Current++) {
  420. iCurImage = iCurImage->Layers;
  421. if (iCurImage == NULL) {
  422. ilSetError(IL_ILLEGAL_OPERATION);
  423. iCurImage = iTempImage;
  424. return IL_FALSE;
  425. }
  426. }
  428. ParentImage = IL_FALSE;
  430. return IL_TRUE;
  431. }
  434. ILuint ILAPIENTRY ilCreateSubImage(ILenum Type, ILuint Num)
  435. {
  436. ILimage *SubImage;
  437. ILuint Count ;  // Create one before we go in the loop.
  439. if (iCurImage == NULL) {
  440. ilSetError(IL_ILLEGAL_OPERATION);
  441. return 0;
  442. }
  443. if (Num == 0)  {
  444. return 0;
  445. }
  447. switch (Type)
  448. {
  449. case IL_SUB_NEXT:
  450. if (iCurImage->Next)
  451. ilCloseImage(iCurImage->Next);
  452. iCurImage->Next = ilNewImage(1, 1, 1, 1, 1);
  453. SubImage = iCurImage->Next;
  454. break;
  456. case IL_SUB_MIPMAP:
  457. if (iCurImage->Mipmaps)
  458. ilCloseImage(iCurImage->Mipmaps);
  459. iCurImage->Mipmaps = ilNewImage(1, 1, 1, 1, 1);
  460. SubImage = iCurImage->Mipmaps;
  461. break;
  463. case IL_SUB_LAYER:
  464. if (iCurImage->Layers)
  465. ilCloseImage(iCurImage->Layers);
  466. iCurImage->Layers = ilNewImage(1, 1, 1, 1, 1);
  467. SubImage = iCurImage->Layers;
  468. break;
  470. default:
  471. ilSetError(IL_INVALID_ENUM);
  472. return IL_FALSE;
  473. }
  475. if (SubImage == NULL) {
  476. return 0;
  477. }
  479. for (Count = 1; Count < Num; Count++) {
  480. SubImage->Next = ilNewImage(1, 1, 1, 1, 1);
  481. SubImage = SubImage->Next;
  482. if (SubImage == NULL)
  483. return Count;
  484. }
  486. return Count;
  487. }
  490. // Returns the current index.
  491. ILAPI ILuint ILAPIENTRY ilGetCurName()
  492. {
  493. if (iCurImage == NULL || ImageStack == NULL || StackSize == 0)
  494. return 0;
  495. return CurName;
  496. }
  499. // Returns the current image.
  500. ILAPI ILimage* ILAPIENTRY ilGetCurImage()
  501. {
  502. return iCurImage;
  503. }
  506. // To be only used when the original image is going to be set back almost immediately.
  507. ILAPI void ILAPIENTRY ilSetCurImage(ILimage *Image)
  508. {
  509. iCurImage = Image;
  510. return;
  511. }
  514. // Completely replaces the current image and the version in the image stack.
  515. ILAPI void ILAPIENTRY ilReplaceCurImage(ILimage *Image)
  516. {
  517. if (iCurImage) {
  518. ilActiveImage(0);
  519. ilCloseImage(iCurImage);
  520. }
  521. ImageStack[ilGetCurName()] = Image;
  522. iCurImage = Image;
  523. ParentImage = IL_TRUE;
  524. return;
  525. }
  528. // Like realloc but sets new memory to 0.
  529. void* ILAPIENTRY ilRecalloc(void *Ptr, ILuint OldSize, ILuint NewSize)
  530. {
  531. void *Temp = ialloc(NewSize);
  532. ILuint CopySize = (OldSize < NewSize) ? OldSize : NewSize;
  534. if (Temp != NULL) {
  535. if (Ptr != NULL) {
  536. memcpy(Temp, Ptr, CopySize);
  537. ifree(Ptr);
  538. }
  540. Ptr = Temp;
  542. if (OldSize < NewSize)
  543. imemclear((ILubyte*)Temp + OldSize, NewSize - OldSize);
  544. }
  546. return Temp;
  547. }
  550. // Internal function to enlarge the image stack by I_STACK_INCREMENT members.
  551. ILboolean iEnlargeStack()
  552. {
  553. // 02-05-2001:  Moved from ilGenImages().
  554. // Puts the cleanup function on the exit handler once.
  555. if (!OnExit) {
  556. #ifdef _MEM_DEBUG
  557. AddToAtexit();  // So iFreeMem doesn't get called after unfreed information.
  558. #endif//_MEM_DEBUG
  559. #if (!defined(_WIN32_WCE)) && (!defined(IL_STATIC_LIB))
  560. atexit((void*)ilShutDown);
  561. #endif
  562. OnExit = IL_TRUE;
  563. }
  565. if (!(ImageStack = (ILimage**)ilRecalloc(ImageStack, StackSize * sizeof(ILimage*), (StackSize + I_STACK_INCREMENT) * sizeof(ILimage*)))) {
  566. return IL_FALSE;
  567. }
  568. StackSize += I_STACK_INCREMENT;
  569. return IL_TRUE;
  570. }
  573. static ILboolean IsInit = IL_FALSE;
  575. /** Call at startup.
  576.  *
  577.  * What exactly this function does can depends on whether DevIL has been built with modular support or static.
  578.  */
  579. void ILAPIENTRY ilInit()
  580. {
  581. // if it is already initialized skip initialization
  582. if (IsInit == IL_TRUE ) 
  583. return;
  584. INIT_LOGGING_IFNEEDED;
  585. INIT_LTDL_IFNEEDED;
  586. /* Some gettext (internationalization support)  */
  587. BIND_TEXTDOMAIN_IFNEEDED;
  588. /* OK, let's load modules and do the stuff */
  589. //Modules * mods = CREATE_MODULES_IFNEEDED;
  590. CREATE_MODULES_IFNEEDED(mods);
  591. /* Then let's fill in the formats */
  592. /* This is PARSED by the ./configure script during build, so don't write those lines in funny ways
  593.  * unless you have malicious intentions. 
  594.  * Doing like
  595.  * SET_FORMAT(& Formats[IL_BMP], mods, BMP, "bmp"); 
  596.  * should be OK 
  597.  */
  598. SET_FORMAT(& Formats[IL_BMP], mods, BMP, "bmp");
  599. SET_FORMAT(& Formats[IL_CUT], mods, CUT, "cut");
  600. SET_FORMAT(& Formats[IL_CHEAD], mods, CHEAD, "h");
  601. SET_FORMAT(& Formats[IL_DCX], mods, DCX, "dcx");
  602. SET_FORMAT(& Formats[IL_DDS], mods, DDS, "dds");
  603. SET_FORMAT(& Formats[IL_DOOM], mods, DOOM, "wad");
  604. SET_FORMAT(& Formats[IL_EXR], mods, EXR, "exr");
  605. SET_FORMAT(& Formats[IL_FITS], mods, FITS, "fits fit");
  606. SET_FORMAT(& Formats[IL_GIF], mods, GIF, "gif");
  607. SET_FORMAT(& Formats[IL_HDR], mods, HDR, "hdr");
  608. SET_FORMAT(& Formats[IL_ICNS], mods, ICNS, "icns");
  609. SET_FORMAT(& Formats[IL_ICON], mods, ICON, "ico cur");
  610. SET_FORMAT(& Formats[IL_IFF], mods, IFF, "iff ilbm lbm");
  611. SET_FORMAT(& Formats[IL_ILBM], mods, ILBM, "ilbm");
  612. SET_FORMAT(& Formats[IL_JPEG], mods, JPEG, "jpeg jpg jpe");
  613. SET_FORMAT(& Formats[IL_JP2], mods, JP2, "jp2");
  614. SET_FORMAT(& Formats[IL_LIF], mods, LIF, "lif");
  615. SET_FORMAT(& Formats[IL_MDL], mods, MDL, "mdl");
  616. SET_FORMAT(& Formats[IL_MNG], mods, MNG, "mng");
  617. SET_FORMAT(& Formats[IL_PCX], mods, PCX, "pcx");
  618. SET_FORMAT(& Formats[IL_PCD], mods, PCD, "pcd");
  619. SET_FORMAT(& Formats[IL_PIC], mods, PIC, "pic");
  620. SET_FORMAT(& Formats[IL_PIX], mods, PIX, "pix");
  621. SET_FORMAT(& Formats[IL_PNG], mods, PNG, "png");
  622. SET_FORMAT(& Formats[IL_PNM], mods, PNM, "pnm pbm pgm ppm");
  623. SET_FORMAT(& Formats[IL_PSD], mods, PSD, "psd");
  624. SET_FORMAT(& Formats[IL_PSP], mods, PSP, "psp");
  625. SET_FORMAT(& Formats[IL_PXR], mods, PXR, "pxr");
  626. SET_FORMAT(& Formats[IL_RAW], mods, RAW, "raw");
  627. SET_FORMAT(& Formats[IL_ROT], mods, ROT, "rot");
  628. SET_FORMAT(& Formats[IL_SGI], mods, SGI, "sgi bw rgb rgba");
  629. SET_FORMAT(& Formats[IL_SUN], mods, SUN, "sun ras rs im1 im8 im24 im32");
  630. SET_FORMAT(& Formats[IL_TEXTURE], mods, TEXTURE, "texture");
  631. SET_FORMAT(& Formats[IL_TGA], mods, TGA, "tga vda icb vst");
  632. SET_FORMAT(& Formats[IL_TIFF], mods, TIFF, "tiff tif");
  633. SET_FORMAT(& Formats[IL_TPL], mods, TPL, "tpl");
  634. SET_FORMAT(& Formats[IL_UTX], mods, UTX, "utx");
  635. SET_FORMAT(& Formats[IL_VTF], mods, VTF, "vtf");
  636. SET_FORMAT(& Formats[IL_WAL], mods, WAL, "wal");
  637. SET_FORMAT(& Formats[IL_WBMP], mods, WBMP, "wbmp");
  638. SET_FORMAT(& Formats[IL_WDP], mods, WDP, "wdp");
  639. SET_FORMAT(& Formats[IL_XPM], mods, XPM, "xpm");
  640. SET_FORMAT(& Formats[IL_BLP], mods, BLP, "blp");
  641. SET_FORMAT(& Formats[IL_IWI], mods, IWI, "iwi");
  642. SET_FORMAT(& Formats[IL_FTX], mods, FTX, "ftx");
  643. SET_FORMAT(& Formats[IL_DICOM], mods, DICOM, "dicom dcm");
  645. /* The original ilInit continues... */
  646. //ilSetMemory(NULL, NULL);  Now useless 3/4/2006 (due to modification in il_alloc.c)
  647. ilSetError(IL_NO_ERROR);
  648. ilDefaultStates();  // Set states to their defaults.
  649. // Sets default file-reading callbacks.
  650. ilResetRead();
  651. ilResetWrite();
  652. #if (!defined(_WIN32_WCE)) && (!defined(IL_STATIC_LIB))
  653. atexit((void*)ilRemoveRegistered);
  654. #endif
  655. //_WIN32_WCE
  656. //ilShutDown();
  657. iSetImage0();  // Beware!  Clears all existing textures!
  658. iBindImageTemp();  // Go ahead and create the temporary image.
  659. IsInit = IL_TRUE;
  660. return;
  661. }
  664. // Frees any extra memory in the stack.
  665. // - Called on exit
  666. void ILAPIENTRY ilShutDown()
  667. {
  668. // if it is not initialized do not shutdown
  669. iFree* TempFree = (iFree*)FreeNames;
  670. ILuint i;
  672. if (!IsInit)
  673. return;
  675. if (!IsInit) {  // Prevent from being called when not initialized.
  676. ilSetError(IL_ILLEGAL_OPERATION);
  677. return;
  678. }
  680. while (TempFree != NULL) {
  681. FreeNames = (iFree*)TempFree->Next;
  682. ifree(TempFree);
  683. TempFree = FreeNames;
  684. }
  686. //for (i = 0; i < LastUsed; i++) {
  687. for (i = 0; i < StackSize; i++) {
  688. if (ImageStack[i] != NULL)
  689. ilCloseImage(ImageStack[i]);
  690. }
  692. if (ImageStack)
  693. ifree(ImageStack);
  694. ImageStack = NULL;
  695. LastUsed = 0;
  696. StackSize = 0;
  697. IL_LOG_IFNEEDED(_("Thank you for closing DevIL properly, bye bye."), IL_LOG_INFO);
  698. IsInit = IL_FALSE;
  699. return;
  700. }
  703. // Initializes the image stack's first entry (default image) -- ONLY CALL ONCE!
  704. void iSetImage0()
  705. {
  706. if (ImageStack == NULL)
  707. if (!iEnlargeStack())
  708. return;
  710. LastUsed = 1;
  711. CurName = 0;
  712. ParentImage = IL_TRUE;
  713. if (!ImageStack[0])
  714. ImageStack[0] = ilNewImage(1, 1, 1, 1, 1);
  715. iCurImage = ImageStack[0];
  716. ilDefaultImage();
  718. return;
  719. }
  722. ILAPI void ILAPIENTRY iBindImageTemp()
  723. {
  724. if (ImageStack == NULL || StackSize <= 1)
  725. if (!iEnlargeStack())
  726. return;
  728. if (LastUsed < 2)
  729. LastUsed = 2;
  730. CurName = 1;
  731. ParentImage = IL_TRUE;
  732. if (!ImageStack[1])
  733. ImageStack[1] = ilNewImage(1, 1, 1, 1, 1);
  734. iCurImage = ImageStack[1];
  736. return;
  737. }