00001 #ifndef DEVIL_CPP_WRAPPER_HPP
00002 #define DEVIL_CPP_WRAPPER_HPP
00003 
00004 #include <IL/ilut.h>  
00005 
00006 class ilImage
00007 {
00008 public:
00009                                 ilImage();
00010                                 ilImage(ILconst_string);
00011                                 ilImage(const ilImage &);
00012         virtual         ~ilImage();
00013 
00014         ILboolean       Load(ILconst_string);
00015         ILboolean       Load(ILconst_string, ILenum);
00016         ILboolean       Save(ILconst_string);
00017         ILboolean       Save(ILconst_string, ILenum);
00018 
00019         
00020         ILboolean       ActiveImage(ILuint);
00021         ILboolean       ActiveLayer(ILuint);
00022         ILboolean       ActiveMipmap(ILuint);
00023         ILboolean       Clear(void);
00024         void            ClearColour(ILclampf, ILclampf, ILclampf, ILclampf);
00025         ILboolean       Convert(ILenum);
00026         ILboolean       Copy(ILuint);
00027         ILboolean       Default(void);
00028         ILboolean       Flip(void);
00029         ILboolean       SwapColours(void);
00030         ILboolean       Resize(ILuint, ILuint, ILuint);
00031         ILboolean       TexImage(ILuint, ILuint, ILuint, ILubyte, ILenum, ILenum, void*);
00032         
00033         
00034         void            Bind(void) const;
00035         void            Bind(ILuint);
00036         void            Close(void) { this->Delete(); }
00037         void            Delete(void);
00038         void            iGenBind();
00039         ILenum          PaletteAlphaIndex();
00040 
00041         
00042         ILuint          Width(void);
00043         ILuint          Height(void);
00044         ILuint          Depth(void);
00045         ILubyte         Bpp(void);
00046         ILubyte         Bitpp(void);
00047         ILenum          PaletteType(void);
00048         ILenum          Format(void);
00049         ILenum          Type(void);
00050         ILuint          NumImages(void);
00051         ILuint          NumMipmaps(void);
00052         ILuint          GetId(void) const;
00053     ILenum      GetOrigin(void);
00054         ILubyte         *GetData(void);
00055         ILubyte         *GetPalette(void);
00056 
00057         
00058         ILuint          BindImage(void);
00059         ILuint          BindImage(ILenum);
00060 
00061         
00062         ilImage&        operator = (ILuint);
00063         ilImage&        operator = (const ilImage &);
00064 
00065 protected:
00066         ILuint          Id;
00067 
00068 private:
00069         static int              ilStartUp();
00070         static ILboolean        ilStartedUp;
00071 };
00072 
00073 
00074 int ilImage::ilStartUp()
00075 {
00076         ilInit();
00077         iluInit();
00078         
00079         return true;
00080 }
00081 ILboolean ilImage::ilStartedUp = ilStartUp();
00082 
00083 class ilFilters
00084 {
00085 public:
00086         static ILboolean        Alienify(ilImage &);
00087         static ILboolean        BlurAvg(ilImage &, ILuint Iter);
00088         static ILboolean        BlurGaussian(ilImage &, ILuint Iter);
00089         static ILboolean        Contrast(ilImage &, ILfloat Contrast);
00090         static ILboolean        EdgeDetectE(ilImage &);
00091         static ILboolean        EdgeDetectP(ilImage &);
00092         static ILboolean        EdgeDetectS(ilImage &);
00093         static ILboolean        Emboss(ilImage &);
00094         static ILboolean        Gamma(ilImage &, ILfloat Gamma);
00095         static ILboolean        Negative(ilImage &);
00096         static ILboolean        Noisify(ilImage &, ILubyte Factor);
00097         static ILboolean        Pixelize(ilImage &, ILuint PixSize);
00098         static ILboolean        Saturate(ilImage &, ILfloat Saturation);
00099         static ILboolean        Saturate(ilImage &, ILfloat r, ILfloat g, ILfloat b, ILfloat Saturation);
00100         static ILboolean        ScaleColours(ilImage &, ILfloat r, ILfloat g, ILfloat b);
00101         static ILboolean        Sharpen(ilImage &, ILfloat Factor, ILuint Iter);
00102 };
00103 
00104 #ifdef ILUT_USE_OPENGL
00105 class ilOgl
00106 {
00107 public:
00108         static void                     Init(void);
00109         static GLuint           BindTex(ilImage &);
00110         static ILboolean        Upload(ilImage &, ILuint);
00111         static GLuint           Mipmap(ilImage &);
00112         static ILboolean        Screen(void);
00113         static ILboolean        Screenie(void);
00114 };
00115 #endif//ILUT_USE_OPENGL
00116 
00117 
00118 #ifdef ILUT_USE_ALLEGRO
00119 class ilAlleg
00120 {
00121 public:
00122         static void     Init(void);
00123         static BITMAP   *Convert(ilImage &);
00124 };
00125 #endif//ILUT_USE_ALLEGRO
00126 
00127 
00128 #ifdef ILUT_USE_WIN32
00129 class ilWin32
00130 {
00131 public:
00132         static void             Init(void);
00133         static HBITMAP          Convert(ilImage &);
00134         static ILboolean        GetClipboard(ilImage &);
00135         static void             GetInfo(ilImage &, BITMAPINFO *Info);
00136         static ILubyte          *GetPadData(ilImage &);
00137         static HPALETTE         GetPal(ilImage &);
00138         static ILboolean        GetResource(ilImage &, HINSTANCE hInst, ILint ID, char *ResourceType);
00139         static ILboolean        GetResource(ilImage &, HINSTANCE hInst, ILint ID, char *ResourceType, ILenum Type);
00140         static ILboolean        SetClipboard(ilImage &);
00141 };
00142 #endif//ILUT_USE_WIN32
00143 
00144 
00145 class ilValidate
00146 {
00147 public:
00148         static ILboolean        Valid(ILenum, ILconst_string);
00149         static ILboolean        Valid(ILenum, FILE *);
00150         static ILboolean        Valid(ILenum, void *, ILuint);
00151 
00152 protected:
00153 
00154 private:
00155 
00156 };
00157 
00158 class ilState
00159 {
00160 public:
00161         static ILboolean                Disable(ILenum);
00162         static ILboolean                Enable(ILenum);
00163         static void                             Get(ILenum, ILboolean &);
00164         static void                             Get(ILenum, ILint &);
00165         static ILboolean                GetBool(ILenum);
00166         static ILint                    GetInt(ILenum);
00167         static const char               *GetString(ILenum);
00168         static ILboolean                IsDisabled(ILenum);
00169         static ILboolean                IsEnabled(ILenum);
00170         static ILboolean                Origin(ILenum);
00171         static void                             Pop(void);
00172         static void                             Push(ILuint);
00173 
00174 protected:
00175 
00176 private:
00177 
00178 };
00179 
00180 
00181 class ilError
00182 {
00183 public:
00184         static void                     Check(void (*Callback)(const char*));
00185         static void                     Check(void (*Callback)(ILenum));
00186         static ILenum           Get(void);
00187         static const char       *String(void);
00188         static const char       *String(ILenum);
00189 
00190 protected:
00191 
00192 private:
00193 
00194 };
00195 
00196 
00197 
00198 
00199 
00200 ilImage::ilImage()
00201 {
00202         this->Id = 0;
00203         
00204         this->iGenBind();
00205         return;
00206 }
00207 
00208 
00209 ilImage::ilImage(ILconst_string FileName)
00210 {
00211         this->Id = 0;
00212         
00213         this->iGenBind();
00214         ilLoadImage(FileName);
00215         return;
00216 }
00217 
00218 
00219 ilImage::ilImage(const ilImage &Image)
00220 {
00221         this->Id = 0;
00222         
00223         this->iGenBind();
00224         *this = Image;
00225         return;
00226 }
00227 
00228 
00229 ilImage::~ilImage()
00230 {
00231         if (this->Id)
00232                 ilDeleteImages(1, &this->Id);
00233         this->Id = 0;
00234         return;
00235 }
00236 
00237 
00238 ILboolean ilImage::Load(ILconst_string FileName)
00239 {
00240         this->iGenBind();
00241         return ilLoadImage(FileName);
00242 }
00243 
00244 
00245 ILboolean ilImage::Load(ILconst_string FileName, ILenum Type)
00246 {
00247         this->iGenBind();
00248         return ilLoad(Type, FileName);
00249 }
00250 
00251 
00252 ILboolean ilImage::Save(ILconst_string FileName)
00253 {
00254         this->iGenBind();
00255         return ilSaveImage(FileName);
00256 }
00257 
00258 
00259 ILboolean ilImage::Save(ILconst_string FileName, ILenum Type)
00260 {
00261         this->iGenBind();
00262         return ilSave(Type, FileName);
00263 }
00264 
00265 
00266 
00267 
00268 
00269 
00270 ILboolean ilImage::ActiveImage(ILuint Number)
00271 {
00272         if (this->Id) {
00273                 this->Bind();
00274                 return ilActiveImage(Number);
00275         }
00276         return IL_FALSE;
00277 }
00278 
00279 
00280 ILboolean ilImage::ActiveLayer(ILuint Number)
00281 {
00282         if (this->Id) {
00283                 this->Bind();
00284                 return ilActiveLayer(Number);
00285         }
00286         return IL_FALSE;
00287 }
00288 
00289 
00290 ILboolean ilImage::ActiveMipmap(ILuint Number)
00291 {
00292         if (this->Id) {
00293                 this->Bind();
00294                 return ilActiveMipmap(Number);
00295         }
00296         return IL_FALSE;
00297 }
00298 
00299 
00300 ILboolean ilImage::Clear()
00301 {
00302         if (this->Id) {
00303                 this->Bind();
00304                 return ilClearImage();
00305         }
00306         return IL_FALSE;
00307 }
00308 
00309 
00310 void ilImage::ClearColour(ILclampf Red, ILclampf Green, ILclampf Blue, ILclampf Alpha)
00311 {
00312         ilClearColour(Red, Green, Blue, Alpha);
00313         return;
00314 }
00315 
00316 
00317 ILboolean ilImage::Convert(ILenum NewFormat)
00318 {
00319         if (this->Id) {
00320                 this->Bind();
00321                 return ilConvertImage(NewFormat, IL_UNSIGNED_BYTE);
00322         }
00323         return IL_FALSE;
00324 }
00325 
00326 
00327 ILboolean ilImage::Copy(ILuint Src)
00328 {
00329         if (this->Id) {
00330                 this->Bind();
00331                 return ilCopyImage(Src);
00332         }
00333         return IL_FALSE;
00334 }
00335 
00336 
00337 ILboolean ilImage::Default()
00338 {
00339         if (this->Id) {
00340                 this->Bind();
00341                 return ilDefaultImage();
00342         }
00343         return IL_FALSE;
00344 }
00345 
00346 
00347 ILboolean ilImage::Flip()
00348 {
00349         if (this->Id) {
00350                 this->Bind();
00351                 return iluFlipImage();
00352         }
00353         return IL_FALSE;
00354 }
00355 
00356 
00357 ILboolean ilImage::SwapColours()
00358 {
00359         if (this->Id) {
00360                 this->Bind();
00361                 return iluSwapColours();
00362         }
00363         return IL_FALSE;
00364 }
00365 
00366 
00367 ILboolean ilImage::Resize(ILuint Width, ILuint Height, ILuint Depth)
00368 {
00369         if (this->Id) {
00370                 this->Bind();
00371                 return iluScale(Width, Height, Depth);
00372         }
00373         return IL_FALSE;
00374 }
00375 
00376 
00377 ILboolean ilImage::TexImage(ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, void *Data)
00378 {
00379         if (this->Id) {
00380                 this->Bind();
00381                 return ilTexImage(Width, Height, Depth, Bpp, Format, Type, Data);
00382         }
00383         return IL_FALSE;
00384 }
00385 
00386 
00387 
00388 
00389 
00390 
00391 void ilImage::Bind() const
00392 {
00393         if (this->Id)
00394                 ilBindImage(this->Id);
00395         return;
00396 }
00397 
00398 
00399 void ilImage::Bind(ILuint Image)
00400 {
00401         if (this->Id == Image)
00402                 return;
00403         this->Delete();  
00404         this->Id = Image;
00405         ilBindImage(this->Id);
00406         return;
00407 }
00408 
00409 
00410 void ilImage::Delete()
00411 {
00412         if (this->Id == 0)
00413                 return;
00414         ilDeleteImages(1, &this->Id);
00415         this->Id = 0;
00416         return;
00417 }
00418 
00419 
00420 
00421 
00422 
00423 
00424 
00425 ILuint ilImage::Width()
00426 {
00427         if (this->Id) {
00428                 this->Bind();
00429                 return ilGetInteger(IL_IMAGE_WIDTH);
00430         }
00431         return 0;
00432 }
00433 
00434 
00435 ILuint ilImage::Height()
00436 {
00437         if (this->Id) {
00438                 this->Bind();
00439                 return ilGetInteger(IL_IMAGE_HEIGHT);
00440         }
00441         return 0;
00442 }
00443 
00444 ILuint ilImage::Depth()
00445 {
00446         if (this->Id) {
00447                 this->Bind();
00448                 return ilGetInteger(IL_IMAGE_DEPTH);
00449         }
00450         return 0;
00451 }
00452 
00453 ILubyte ilImage::Bpp()
00454 {
00455         if (this->Id) {
00456                 this->Bind();
00457                 return ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);
00458         }
00459         return 0;
00460 }
00461 
00462 ILubyte ilImage::Bitpp()
00463 {
00464         if (this->Id) {
00465                 this->Bind();
00466                 return ilGetInteger(IL_IMAGE_BITS_PER_PIXEL);
00467         }
00468         return 0;
00469 }
00470 
00471 ILenum ilImage::Format()
00472 {
00473         if (this->Id) {
00474                 this->Bind();
00475                 return ilGetInteger(IL_IMAGE_FORMAT);
00476         }
00477         return 0;
00478 }
00479 
00480 ILenum ilImage::PaletteType()
00481 {
00482         if (this->Id) {
00483                 this->Bind();
00484                 return ilGetInteger(IL_PALETTE_TYPE);
00485         }
00486         return 0;
00487 }
00488 
00489 ILenum ilImage::PaletteAlphaIndex()
00490 {
00491         if (this->Id) {
00492                 this->Bind();
00493                 return ilGetInteger(IL_PNG_ALPHA_INDEX);
00494         }
00495         return 0;
00496 }
00497 
00498 ILenum ilImage::Type()
00499 {
00500         if (this->Id) {
00501                 this->Bind();
00502                 return ilGetInteger(IL_IMAGE_TYPE);
00503         }
00504         return 0;
00505 }
00506 
00507 ILenum ilImage::NumImages()
00508 {
00509         if (this->Id) {
00510                 this->Bind();
00511                 return ilGetInteger(IL_NUM_IMAGES);
00512         }
00513         return 0;
00514 }
00515 
00516 ILenum ilImage::NumMipmaps()
00517 {
00518         if (this->Id) {
00519                 this->Bind();
00520                 return ilGetInteger(IL_NUM_MIPMAPS);
00521         }
00522         return 0;
00523 }
00524 
00525 ILuint ilImage::GetId() const
00526 {
00527         return this->Id;
00528 }
00529 
00530 ILenum ilImage::GetOrigin(void)
00531 {
00532     ILinfo Info;
00533 
00534         if (this->Id) {
00535                 this->Bind();
00536         iluGetImageInfo(&Info);
00537                 return Info.Origin;
00538         }
00539         return 0;
00540 }
00541 
00542 ILubyte* ilImage::GetData()
00543 {
00544         if (this->Id) {
00545                 this->Bind();
00546                 return ilGetData();
00547         }
00548         return 0;
00549 }
00550 
00551 ILubyte* ilImage::GetPalette()
00552 {
00553         if (this->Id) {
00554                 this->Bind();
00555                 return ilGetPalette();
00556         }
00557         return 0;
00558 }
00559 
00560 
00561 
00562 
00563 
00564 
00565 
00566 
00567 
00568 
00569 
00570 
00571 void ilImage::iGenBind()
00572 {
00573         if (this->Id == 0) {
00574                 ilGenImages(1, &this->Id);
00575         }
00576         ilBindImage(this->Id);
00577         return;
00578 }
00579 
00580 
00581 
00582 
00583 ilImage& ilImage::operator = (ILuint Image)
00584 {
00585         if (this->Id == 0)
00586                 this->Id = Image;
00587         else {
00588                 this->Bind();
00589                 ilCopyImage(Image);
00590         }
00591 
00592         return *this;
00593 }
00594 
00595 ilImage& ilImage::operator = (const ilImage &Image)
00596 {
00597         if (Id == 0)
00598                 Id = Image.GetId();
00599         else {
00600                 Bind();
00601                 ilCopyImage(Image.GetId());
00602         }
00603 
00604         return *this;
00605 }
00606 
00607 
00608 
00609 
00610 ILboolean ilFilters::Alienify(ilImage &Image)
00611 {
00612         Image.Bind();
00613         return iluAlienify();
00614 }
00615 
00616 ILboolean ilFilters::BlurAvg(ilImage &Image, ILuint Iter)
00617 {
00618         Image.Bind();
00619         return iluBlurAvg(Iter);
00620 }
00621 
00622 ILboolean ilFilters::BlurGaussian(ilImage &Image, ILuint Iter)
00623 {
00624         Image.Bind();
00625         return iluBlurGaussian(Iter);
00626 }
00627 
00628 ILboolean ilFilters::Contrast(ilImage &Image, ILfloat Contrast)
00629 {
00630         Image.Bind();
00631         return iluContrast(Contrast);
00632 }
00633 
00634 ILboolean ilFilters::EdgeDetectE(ilImage &Image)
00635 {
00636         Image.Bind();
00637         return iluEdgeDetectP();
00638 }
00639 
00640 ILboolean ilFilters::EdgeDetectP(ilImage &Image)
00641 {
00642         Image.Bind();
00643         return iluEdgeDetectP();
00644 }
00645 
00646 ILboolean ilFilters::EdgeDetectS(ilImage &Image)
00647 {
00648         Image.Bind();
00649         return iluEdgeDetectS();
00650 }
00651 
00652 ILboolean ilFilters::Emboss(ilImage &Image)
00653 {
00654         Image.Bind();
00655         return iluEmboss();
00656 }
00657 
00658 ILboolean ilFilters::Gamma(ilImage &Image, ILfloat Gamma)
00659 {
00660         Image.Bind();
00661         return iluGammaCorrect(Gamma);
00662 }
00663 
00664 ILboolean ilFilters::Negative(ilImage &Image)
00665 {
00666         Image.Bind();
00667         return iluNegative();
00668 }
00669 
00670 ILboolean ilFilters::Noisify(ilImage &Image, ILubyte Factor)
00671 {
00672         Image.Bind();
00673         return iluNoisify(Factor);
00674 }
00675 
00676 ILboolean ilFilters::Pixelize(ilImage &Image, ILuint PixSize)
00677 {
00678         Image.Bind();
00679         return iluPixelize(PixSize);
00680 }
00681 
00682 ILboolean ilFilters::Saturate(ilImage &Image, ILfloat Saturation)
00683 {
00684         Image.Bind();
00685         return iluSaturate1f(Saturation);
00686 }
00687 
00688 ILboolean ilFilters::Saturate(ilImage &Image, ILfloat r, ILfloat g, ILfloat b, ILfloat Saturation)
00689 {
00690         Image.Bind();
00691         return iluSaturate4f(r, g, b, Saturation);
00692 }
00693 
00694 ILboolean ilFilters::ScaleColours(ilImage &Image, ILfloat r, ILfloat g, ILfloat b)
00695 {
00696         Image.Bind();
00697         return iluScaleColours(r, g, b);
00698 }
00699 
00700 
00701 ILboolean ilFilters::Sharpen(ilImage &Image, ILfloat Factor, ILuint Iter)
00702 {
00703         Image.Bind();
00704         return iluSharpen(Factor, Iter);
00705 }
00706 
00707 
00708 
00709 
00710 
00711 #ifdef ILUT_USE_OPENGL
00712 void ilOgl::Init()
00713 {
00714         ilutRenderer(ILUT_OPENGL);
00715         return;
00716 }
00717 
00718 
00719 GLuint ilOgl::BindTex(ilImage &Image)
00720 {
00721         Image.Bind();
00722         return ilutGLBindTexImage();
00723 }
00724 
00725 ILboolean ilOgl::Upload(ilImage &Image, ILuint Level)
00726 {
00727         Image.Bind();
00728         return ilutGLTexImage(Level);
00729 }
00730 
00731 
00732 GLuint ilOgl::Mipmap(ilImage &Image)
00733 {
00734         Image.Bind();
00735         return ilutGLBuildMipmaps();
00736 }
00737 
00738 ILboolean ilOgl::Screen()
00739 {
00740         return ilutGLScreen();
00741 }
00742 
00743 
00744 ILboolean ilOgl::Screenie()
00745 {
00746         return ilutGLScreenie();
00747 }
00748 #endif//ILUT_USE_OPENGL
00749 
00750 
00751 
00752 
00753 #ifdef ILUT_USE_ALLEGRO
00754 void ilAlleg::Init()
00755 {
00756         ilutRenderer(IL_ALLEGRO);
00757         return;
00758 }
00759 
00760 BITMAP *ilAlleg::Convert(ilImage &Image, PALETTE Pal)
00761 {
00762         Image.Bind();
00763         return ilutConvertToAlleg(Pal);
00764 }
00765 #endif//ILUT_USE_ALLEGRO
00766 
00767 
00768 
00769 
00770 #ifdef ILUT_USE_WIN32
00771 void ilWin32::Init()
00772 {
00773         ilutRenderer(ILUT_WIN32);
00774         return;
00775 }
00776 
00777 HBITMAP ilWin32::Convert(ilImage &Image)
00778 {
00779         Image.Bind();
00780         return ilutConvertToHBitmap(GetDC(NULL));
00781 }
00782 
00783 ILboolean ilWin32::GetClipboard(ilImage &Image)
00784 {
00785         Image.Bind();
00786         return ilutGetWinClipboard();
00787 }
00788 
00789 void ilWin32::GetInfo(ilImage &Image, BITMAPINFO *Info)
00790 {
00791         Image.Bind();
00792         ilutGetBmpInfo(Info);
00793         return;
00794 }
00795 
00796 ILubyte* ilWin32::GetPadData(ilImage &Image)
00797 {
00798         Image.Bind();
00799         return ilutGetPaddedData();
00800 }
00801 
00802 HPALETTE ilWin32::GetPal(ilImage &Image)
00803 {
00804         Image.Bind();
00805         return ilutGetHPal();
00806 }
00807 
00808 ILboolean ilWin32::GetResource(ilImage &Image, HINSTANCE hInst, ILint ID, char *ResourceType)
00809 {
00810         Image.Bind();
00811         return ilutLoadResource(hInst, ID, ResourceType, IL_TYPE_UNKNOWN);
00812 }
00813 
00814 ILboolean ilWin32::GetResource(ilImage &Image, HINSTANCE hInst, ILint ID, char *ResourceType, ILenum Type)
00815 {
00816         Image.Bind();
00817         return ilutLoadResource(hInst, ID, ResourceType, Type);
00818 }
00819 
00820 ILboolean ilWin32::SetClipboard(ilImage &Image)
00821 {
00822         Image.Bind();
00823         return ilutSetWinClipboard();
00824 }
00825 #endif//ILUT_USE_WIN32
00826 
00827 
00828 
00829 
00830 ILboolean ilValidate::Valid(ILenum Type, ILconst_string FileName)
00831 {
00832         return ilIsValid(Type, FileName);
00833 }
00834 
00835 ILboolean ilValidate::Valid(ILenum Type, FILE *File)
00836 {
00837         return ilIsValidF(Type, File);
00838 }
00839 
00840 ILboolean ilValidate::Valid(ILenum Type, void *Lump, ILuint Size)
00841 {
00842         return ilIsValidL(Type, Lump, Size);
00843 }
00844 
00845 
00846 
00847 
00848 ILboolean ilState::Disable(ILenum State)
00849 {
00850         return ilDisable(State);
00851 }
00852 
00853 ILboolean ilState::Enable(ILenum State)
00854 {
00855         return ilEnable(State);
00856 }
00857 
00858 void ilState::Get(ILenum Mode, ILboolean &Param)
00859 {
00860         ilGetBooleanv(Mode, &Param);
00861         return;
00862 }
00863 
00864 void ilState::Get(ILenum Mode, ILint &Param)
00865 {
00866         ilGetIntegerv(Mode, &Param);
00867         return;
00868 }
00869 
00870 ILboolean ilState::GetBool(ILenum Mode)
00871 {
00872         return ilGetBoolean(Mode);
00873 }
00874 
00875 ILint ilState::GetInt(ILenum Mode)
00876 {
00877         return ilGetInteger(Mode);
00878 }
00879 
00880 const char *ilState::GetString(ILenum StringName)
00881 {
00882         return ilGetString(StringName);
00883 }
00884 
00885 ILboolean ilState::IsDisabled(ILenum Mode)
00886 {
00887         return ilIsDisabled(Mode);
00888 }
00889 
00890 ILboolean ilState::IsEnabled(ILenum Mode)
00891 {
00892         return ilIsEnabled(Mode);
00893 }
00894 
00895 ILboolean ilState::Origin(ILenum Mode)
00896 {
00897         return ilOriginFunc(Mode);
00898 }
00899 
00900 void ilState::Pop()
00901 {
00902         ilPopAttrib();
00903         return;
00904 }
00905 
00906 void ilState::Push(ILuint Bits = IL_ALL_ATTRIB_BITS)
00907 {
00908         ilPushAttrib(Bits);
00909         return;
00910 }
00911 
00912 
00913 
00914 
00915 void ilError::Check(void (*Callback)(const char*))
00916 {
00917         static ILenum Error;
00918 
00919         while ((Error = ilGetError()) != IL_NO_ERROR) {
00920                 Callback(iluErrorString(Error));
00921         }
00922 
00923         return;
00924 }
00925 
00926 void ilError::Check(void (*Callback)(ILenum))
00927 {
00928         static ILenum Error;
00929 
00930         while ((Error = ilGetError()) != IL_NO_ERROR) {
00931                 Callback(Error);
00932         }
00933 
00934         return;
00935 }
00936 
00937 ILenum ilError::Get()
00938 {
00939         return ilGetError();
00940 }
00941 
00942 const char *ilError::String()
00943 {
00944         return iluErrorString(ilGetError());
00945 }
00946 
00947 const char *ilError::String(ILenum Error)
00948 {
00949         return iluErrorString(Error);
00950 }
00951 
00952 #endif// DEVIL_CPP_WRAPPER_HPP