Attachment #120348 for bug #179843

View | Details | Raw Unified | Return to bug 179843
Collapse All | Expand All

Lines 374-380 ILuint ilImage::GetId() const Link Here

(-)DevIL-1.6.7/cpp wrapper/il_wrap.cpp (-1 / +1 lines)
374	return this->Id;	374	return this->Id;
375	}	375	}
376		376
377	ILenum ilImage::GetOrigin(ILvoid)	377	ILenum ilImage::GetOrigin(void)
378	{	378	{
379	ILinfo Info;	379	ILinfo Info;
380		380




#endif

// Internal library functions in IL
ILAPI ILimage*		ILAPIENTRY ilGetCurImage(void);
ILAPI ILvoid		ILAPIENTRY ilSetCurImage(ILimage *Image);
ILAPI ILvoid		ILAPIENTRY ilSetError(ILenum Error);
ILAPI ILvoid		ILAPIENTRY ilSetPal(ILpal *Pal);

//
// Image functions
//
ILAPI ILvoid    ILAPIENTRY iBindImageTemp  (void);
ILAPI ILboolean ILAPIENTRY ilClearImage_   (ILimage *Image);
ILAPI ILvoid    ILAPIENTRY ilCloseImage    (ILimage *Image);
ILAPI ILvoid    ILAPIENTRY ilClosePal      (ILpal *Palette);
ILAPI ILpal*    ILAPIENTRY iCopyPal        (void);
ILAPI ILboolean ILAPIENTRY ilCopyImageAttr (ILimage *Dest, ILimage *Src);
ILAPI ILimage*  ILAPIENTRY ilCopyImage_    (ILimage *Src);
ILAPI ILvoid    ILAPIENTRY ilGetClear      (ILvoid *Colours, ILenum Format, ILenum Type);
ILAPI ILuint    ILAPIENTRY ilGetCurName    (void);
ILAPI ILboolean ILAPIENTRY ilIsValidPal    (ILpal *Palette);
ILAPI ILimage*  ILAPIENTRY ilNewImage      (ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILubyte Bpc);
ILAPI ILimage*  ILAPIENTRY ilNewImageFull  (ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, ILvoid *Data);




ILAPI ILvoid		ILAPIENTRY ilBindImage(ILuint Image);
ILAPI ILboolean		ILAPIENTRY ilBlit(ILuint Source, ILint DestX, ILint DestY, ILint DestZ, ILuint SrcX, ILuint SrcY, ILuint SrcZ, ILuint Width, ILuint Height, ILuint Depth);
ILAPI ILvoid		ILAPIENTRY ilClearColour(ILclampf Red, ILclampf Green, ILclampf Blue, ILclampf Alpha);
ILAPI ILboolean		ILAPIENTRY ilClearImage(void);
ILAPI ILuint		ILAPIENTRY ilCloneCurImage(void);
ILAPI ILboolean		ILAPIENTRY ilCompressFunc(ILenum Mode);
ILAPI ILboolean		ILAPIENTRY ilConvertImage(ILenum DestFormat, ILenum DestType);
ILAPI ILboolean		ILAPIENTRY ilConvertPal(ILenum DestFormat);
ILAPI ILboolean		ILAPIENTRY ilCopyImage(ILuint Src);
ILAPI ILuint		ILAPIENTRY ilCopyPixels(ILuint XOff, ILuint YOff, ILuint ZOff, ILuint Width, ILuint Height, ILuint Depth, ILenum Format, ILenum Type, ILvoid *Data);
ILAPI ILuint		ILAPIENTRY ilCreateSubImage(ILenum Type, ILuint Num);
ILAPI ILboolean		ILAPIENTRY ilDefaultImage(void);
ILAPI ILvoid		ILAPIENTRY ilDeleteImages(ILsizei Num, const ILuint *Images);
ILAPI ILboolean		ILAPIENTRY ilDisable(ILenum Mode);
ILAPI ILboolean		ILAPIENTRY ilEnable(ILenum Mode);

ILAPI ILvoid            ILAPIENTRY ilSetAlpha( ILdouble AlphaValue );
ILAPI ILboolean		ILAPIENTRY ilGetBoolean(ILenum Mode);
ILAPI ILvoid		ILAPIENTRY ilGetBooleanv(ILenum Mode, ILboolean *Param);
ILAPI ILubyte*		ILAPIENTRY ilGetData(void);
ILAPI ILuint		ILAPIENTRY ilGetDXTCData(ILvoid *Buffer, ILuint BufferSize, ILenum DXTCFormat);
ILAPI ILenum		ILAPIENTRY ilGetError(void);
ILAPI ILint             ILAPIENTRY ilGetInteger(ILenum Mode);
ILAPI ILvoid		ILAPIENTRY ilGetIntegerv(ILenum Mode, ILint *Param);
ILAPI ILuint		ILAPIENTRY ilGetLumpPos(void);
ILAPI ILubyte*		ILAPIENTRY ilGetPalette(void);
ILAPI const ILstring    ILAPIENTRY ilGetString(ILenum StringName);
ILAPI ILvoid		ILAPIENTRY ilHint(ILenum Target, ILenum Mode);
ILAPI ILvoid		ILAPIENTRY ilInit(void);
ILAPI ILboolean		ILAPIENTRY ilIsDisabled(ILenum Mode);
ILAPI ILboolean		ILAPIENTRY ilIsEnabled(ILenum Mode);
ILAPI ILboolean		ILAPIENTRY ilIsImage(ILuint Image);

ILAPI ILboolean		ILAPIENTRY ilLoadPal(const ILstring FileName);
ILAPI ILboolean		ILAPIENTRY ilOriginFunc(ILenum Mode);
ILAPI ILboolean		ILAPIENTRY ilOverlayImage(ILuint Source, ILint XCoord, ILint YCoord, ILint ZCoord);
ILAPI ILvoid		ILAPIENTRY ilPopAttrib(void);
ILAPI ILvoid		ILAPIENTRY ilPushAttrib(ILuint Bits);
ILAPI ILvoid		ILAPIENTRY ilRegisterFormat(ILenum Format);
ILAPI ILboolean		ILAPIENTRY ilRegisterLoad(const ILstring Ext, IL_LOADPROC Load);

ILAPI ILvoid		ILAPIENTRY ilRegisterType(ILenum Type);
ILAPI ILboolean		ILAPIENTRY ilRemoveLoad(const ILstring Ext);
ILAPI ILboolean		ILAPIENTRY ilRemoveSave(const ILstring Ext);
ILAPI ILvoid		ILAPIENTRY ilResetMemory(void);
ILAPI ILvoid		ILAPIENTRY ilResetRead(void);
ILAPI ILvoid		ILAPIENTRY ilResetWrite(void);
ILAPI ILboolean		ILAPIENTRY ilSave(ILenum Type, const ILstring FileName);
ILAPI ILuint		ILAPIENTRY ilSaveF(ILenum Type, ILHANDLE File);
ILAPI ILboolean		ILAPIENTRY ilSaveImage(const ILstring FileName);

ILAPI ILvoid		ILAPIENTRY ilSetRead(fOpenRProc, fCloseRProc, fEofProc, fGetcProc, fReadProc, fSeekRProc, fTellRProc);
ILAPI ILvoid		ILAPIENTRY ilSetString(ILenum Mode, const char *String);
ILAPI ILvoid		ILAPIENTRY ilSetWrite(fOpenWProc, fCloseWProc, fPutcProc, fSeekWProc, fTellWProc, fWriteProc);
ILAPI ILvoid		ILAPIENTRY ilShutDown(void);
ILAPI ILboolean		ILAPIENTRY ilTexImage(ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, ILvoid *Data);
ILAPI ILboolean		ILAPIENTRY ilTypeFunc(ILenum Mode);







// ImageLib Utility Functions
ILAPI ILboolean			ILAPIENTRY iluAlienify(void);
ILAPI ILboolean			ILAPIENTRY iluBlurAvg(ILuint Iter);
ILAPI ILboolean			ILAPIENTRY iluBlurGaussian(ILuint Iter);
ILAPI ILboolean			ILAPIENTRY iluBuildMipmaps(void);
ILAPI ILuint			ILAPIENTRY iluColoursUsed(void);
ILAPI ILboolean			ILAPIENTRY iluCompareImage(ILuint Comp);
ILAPI ILboolean			ILAPIENTRY iluContrast(ILfloat Contrast);
ILAPI ILboolean			ILAPIENTRY iluCrop(ILuint XOff, ILuint YOff, ILuint ZOff, ILuint Width, ILuint Height, ILuint Depth);
ILAPI ILvoid			ILAPIENTRY iluDeleteImage(ILuint Id);
ILAPI ILboolean			ILAPIENTRY iluEdgeDetectE(void);
ILAPI ILboolean			ILAPIENTRY iluEdgeDetectP(void);
ILAPI ILboolean			ILAPIENTRY iluEdgeDetectS(void);
ILAPI ILboolean			ILAPIENTRY iluEmboss(void);
ILAPI ILboolean			ILAPIENTRY iluEnlargeCanvas(ILuint Width, ILuint Height, ILuint Depth);
ILAPI ILboolean			ILAPIENTRY iluEnlargeImage(ILfloat XDim, ILfloat YDim, ILfloat ZDim);
ILAPI ILboolean			ILAPIENTRY iluEqualize(void);
ILAPI const ILstring	ILAPIENTRY iluErrorString(ILenum Error);
ILAPI ILboolean			ILAPIENTRY iluFlipImage(void);
ILAPI ILboolean			ILAPIENTRY iluGammaCorrect(ILfloat Gamma);
ILAPI ILuint			ILAPIENTRY iluGenImage(void);
ILAPI ILvoid			ILAPIENTRY iluGetImageInfo(ILinfo *Info);
ILAPI ILint				ILAPIENTRY iluGetInteger(ILenum Mode);
ILAPI ILvoid			ILAPIENTRY iluGetIntegerv(ILenum Mode, ILint *Param);
ILAPI const ILstring	ILAPIENTRY iluGetString(ILenum StringName);
ILAPI ILvoid			ILAPIENTRY iluImageParameter(ILenum PName, ILenum Param);
ILAPI ILvoid			ILAPIENTRY iluInit(void);
ILAPI ILboolean			ILAPIENTRY iluInvertAlpha(void);
ILAPI ILuint			ILAPIENTRY iluLoadImage(const ILstring FileName);
ILAPI ILboolean			ILAPIENTRY iluMirror(void);
ILAPI ILboolean			ILAPIENTRY iluNegative(void);
ILAPI ILboolean			ILAPIENTRY iluNoisify(ILclampf Tolerance);
ILAPI ILboolean			ILAPIENTRY iluPixelize(ILuint PixSize);
ILAPI ILvoid			ILAPIENTRY iluRegionfv(ILpointf *Points, ILuint n);

ILAPI ILboolean			ILAPIENTRY iluScale(ILuint Width, ILuint Height, ILuint Depth);
ILAPI ILboolean			ILAPIENTRY iluScaleColours(ILfloat r, ILfloat g, ILfloat b);
ILAPI ILboolean			ILAPIENTRY iluSharpen(ILfloat Factor, ILuint Iter);
ILAPI ILboolean			ILAPIENTRY iluSwapColours(void);
ILAPI ILboolean			ILAPIENTRY iluWave(ILfloat Angle);

#define iluColorsUsed	iluColoursUsed




ILAPI ILint			ILAPIENTRY ilutGetInteger(ILenum Mode);
ILAPI ILvoid		ILAPIENTRY ilutGetIntegerv(ILenum Mode, ILint *Param);
ILAPI const ILstring		ILAPIENTRY ilutGetString(ILenum StringName);
ILAPI ILvoid		ILAPIENTRY ilutInit(void);
ILAPI ILboolean		ILAPIENTRY ilutIsDisabled(ILenum Mode);
ILAPI ILboolean		ILAPIENTRY ilutIsEnabled(ILenum Mode);
ILAPI ILvoid		ILAPIENTRY ilutPopAttrib(void);
ILAPI ILvoid		ILAPIENTRY ilutPushAttrib(ILuint Bits);
ILAPI ILvoid		ILAPIENTRY ilutSetInteger(ILenum Mode, ILint Param);


	#endif//__APPLE__

	ILAPI GLuint	ILAPIENTRY ilutGLBindTexImage();
	ILAPI GLuint	ILAPIENTRY ilutGLBindMipmaps(void);
	ILAPI ILboolean	ILAPIENTRY ilutGLBuildMipmaps(void);
	ILAPI GLuint	ILAPIENTRY ilutGLLoadImage(const ILstring FileName);
	ILAPI ILboolean	ILAPIENTRY ilutGLScreen(void);
	ILAPI ILboolean	ILAPIENTRY ilutGLScreenie(void);
	ILAPI ILboolean	ILAPIENTRY ilutGLSaveImage(const ILstring FileName, GLuint TexID);
	ILAPI ILboolean	ILAPIENTRY ilutGLSetTex(GLuint TexID);
	ILAPI ILboolean	ILAPIENTRY ilutGLTexImage(GLuint Level);


// ImageLib Utility Toolkit's BeOS Functions
#ifdef  ILUT_USE_BEOS
	ILAPI BBitmap ILAPIENTRY ilutConvertToBBitmap(void);
#endif//ILUT_USE_BEOS



		ILAPI HBITMAP	ILAPIENTRY ilutConvertSliceToHBitmap(HDC hDC, ILuint slice);
		ILAPI ILvoid	ILAPIENTRY ilutFreePaddedData(ILubyte *Data);
		ILAPI ILvoid	ILAPIENTRY ilutGetBmpInfo(BITMAPINFO *Info);
		ILAPI HPALETTE	ILAPIENTRY ilutGetHPal(void);
		ILAPI ILubyte*	ILAPIENTRY ilutGetPaddedData(void);
		ILAPI ILboolean	ILAPIENTRY ilutGetWinClipboard(void);
		ILAPI ILboolean	ILAPIENTRY ilutLoadResource(HINSTANCE hInst, ILint ID, const ILstring ResourceType, ILenum Type);
		ILAPI ILboolean	ILAPIENTRY ilutSetHBitmap(HBITMAP Bitmap);
		ILAPI ILboolean	ILAPIENTRY ilutSetHPal(HPALETTE Pal);
		ILAPI ILboolean	ILAPIENTRY ilutSetWinClipboard(void);
		ILAPI HBITMAP	ILAPIENTRY ilutWinLoadImage(const ILstring FileName, HDC hDC);
		ILAPI ILboolean	ILAPIENTRY ilutWinLoadUrl(const ILstring Url);
		ILAPI ILboolean ILAPIENTRY ilutWinPrint(ILuint XPos, ILuint YPos, ILuint Width, ILuint Height, HDC hDC);




	ILboolean	ActiveImage(ILuint);
	ILboolean	ActiveLayer(ILuint);
	ILboolean	ActiveMipmap(ILuint);
	ILboolean	Clear(void);
	ILvoid		ClearColour(ILubyte, ILubyte, ILubyte, ILubyte);
	ILboolean	Convert(ILenum);
	ILboolean	Copy(ILuint);
	ILboolean	Default(void);
	ILboolean	Flip(void);
	ILboolean	SwapColours(void);
	ILboolean	Resize(ILuint, ILuint, ILuint);
	ILboolean	TexImage(ILuint, ILuint, ILuint, ILubyte, ILenum, ILenum, ILvoid*);

	
	// Image handling
	ILvoid		Bind(void) const;
	ILvoid		Bind(ILuint);
	ILvoid		Close(void) { this->Delete(); }
	ILvoid		Delete(void);
	ILvoid		iGenBind();


	// Image characteristics
	ILuint		Width(void);
	ILuint		Height(void);
	ILuint		Depth(void);
	ILubyte		Bpp(void);
	ILubyte		Bitpp(void);
	ILenum		PaletteType(void);
	ILenum		Format(void);
	ILenum		Type(void);
	ILuint		NumImages(void);
	ILuint		NumMipmaps(void);
	ILuint		GetId(void) const;
    ILenum      GetOrigin(void);
	ILubyte		*GetData(void);
	ILubyte		*GetPalette(void);


	// Rendering
	ILuint		BindImage(void);
	ILuint		BindImage(ILenum);



class ilOgl
{
public:
	static ILvoid		Init(void);
	static GLuint		BindTex(ilImage &);
	static ILboolean	Upload(ilImage &, ILuint);
	static GLuint		Mipmap(ilImage &);
	static ILboolean	Screen(void);
	static ILboolean	Screenie(void);
};
#endif//ILUT_USE_OPENGL


class ilAlleg
{
public:
	static ILvoid	Init(void);
	static BITMAP	*Convert(ilImage &);
};
#endif//ILUT_USE_ALLEGRO

class ilWin32
{
public:
	static ILvoid		Init(void);
	static HBITMAP		Convert(ilImage &);
	static ILboolean	GetClipboard(ilImage &);
	static ILvoid		GetInfo(ilImage &, BITMAPINFO *Info);

	static ILboolean		IsDisabled(ILenum);
	static ILboolean		IsEnabled(ILenum);
	static ILboolean		Origin(ILenum);
	static ILvoid			Pop(void);
	static ILvoid			Push(ILuint);



public:
	static ILvoid		Check(ILvoid (*Callback)(const char*));
	static ILvoid		Check(ILvoid (*Callback)(ILenum));
	static ILenum		Get(void);
	static const char	*String(void);
	static const char	*String(ILenum);

protected:

Lines 56-64 typedef struct ILimage Link Here

(-)DevIL-1.6.7/projects/msvc/gdi+/DevIL-GDI+.cpp (-2 / +2 lines)
56		56
57	ILAPI ILimage* ILAPIENTRY iConvertImage(ILenum DestFormat, ILenum DestType);	57	ILAPI ILimage* ILAPIENTRY iConvertImage(ILenum DestFormat, ILenum DestType);
58	ILAPI ILubyte* ILAPIENTRY iGetPaddedData(ILimage *Image);	58	ILAPI ILubyte* ILAPIENTRY iGetPaddedData(ILimage *Image);
59	ILAPI ILimage* ILAPIENTRY ilGetCurImage(ILvoid);	59	ILAPI ILimage* ILAPIENTRY ilGetCurImage(void);
60	ILAPI ILvoid ILAPIENTRY ilCloseImage(ILimage *Image);	60	ILAPI ILvoid ILAPIENTRY ilCloseImage(ILimage *Image);
61	ILAPI ILvoid ILAPIENTRY iBindImageTemp(ILvoid);	61	ILAPI ILvoid ILAPIENTRY iBindImageTemp(void);
62		62
63		63
64	// @TODO: Use 48-bit and 64-bit types.	64	// @TODO: Use 48-bit and 64-bit types.

Lines 56-64 typedef struct ILimage Link Here

(-)DevIL-1.6.7/projects/msvc/mfc/DevIL-MFC.cpp (-2 / +2 lines)
56		56
57	ILAPI ILimage* ILAPIENTRY iConvertImage(ILenum DestFormat, ILenum DestType);	57	ILAPI ILimage* ILAPIENTRY iConvertImage(ILenum DestFormat, ILenum DestType);
58	ILAPI ILubyte* ILAPIENTRY iGetPaddedData(ILimage *Image);	58	ILAPI ILubyte* ILAPIENTRY iGetPaddedData(ILimage *Image);
59	ILAPI ILimage* ILAPIENTRY ilGetCurImage(ILvoid);	59	ILAPI ILimage* ILAPIENTRY ilGetCurImage(void);
60	ILAPI ILvoid ILAPIENTRY ilCloseImage(ILimage *Image);	60	ILAPI ILvoid ILAPIENTRY ilCloseImage(ILimage *Image);
61	ILAPI ILvoid ILAPIENTRY iBindImageTemp(ILvoid);	61	ILAPI ILvoid ILAPIENTRY iBindImageTemp(void);
62		62
63		63
64	CBitmap *ilutConvertToCBitmap()	64	CBitmap *ilutConvertToCBitmap()

Lines 23-31 Link Here

(-)DevIL-1.6.7/projects/msvc/mfc/DevIL-MFC.h (-2 / +2 lines)
23	struct ILimage;	23	struct ILimage;
24	ILAPI ILimage* ILAPIENTRY iConvertImage(ILenum DestFormat, ILenum DestType);	24	ILAPI ILimage* ILAPIENTRY iConvertImage(ILenum DestFormat, ILenum DestType);
25	ILAPI ILubyte* ILAPIENTRY iGetPaddedData(ILimage *Image);	25	ILAPI ILubyte* ILAPIENTRY iGetPaddedData(ILimage *Image);
26	ILAPI ILimage* ILAPIENTRY ilGetCurImage(ILvoid);	26	ILAPI ILimage* ILAPIENTRY ilGetCurImage(void);
27	ILAPI ILvoid ILAPIENTRY ilCloseImage(ILimage *Image);	27	ILAPI ILvoid ILAPIENTRY ilCloseImage(ILimage *Image);
28	ILAPI ILvoid ILAPIENTRY iBindImageTemp(ILvoid);	28	ILAPI ILvoid ILAPIENTRY iBindImageTemp(void);
29		29
30	// Functions for the static library.	30	// Functions for the static library.
31	CBitmap *ilutConvertToCBitmap();	31	CBitmap *ilutConvertToCBitmap();

Lines 63-73 typedef struct OS2_HEAD Link Here

(-)DevIL-1.6.7/src-IL/include/il_bmp.h (-3 / +3 lines)
63	// Internal functions	63	// Internal functions
64	ILboolean iGetBmpHead(BMPHEAD *Header);	64	ILboolean iGetBmpHead(BMPHEAD *Header);
65	ILboolean iGetOS2Head(OS2_HEAD *Header);	65	ILboolean iGetOS2Head(OS2_HEAD *Header);
66	ILboolean iIsValidBmp(ILvoid);	66	ILboolean iIsValidBmp(void);
67	ILboolean iCheckBmp(BMPHEAD *Header);	67	ILboolean iCheckBmp(BMPHEAD *Header);
68	ILboolean iCheckOS2(OS2_HEAD *Header);	68	ILboolean iCheckOS2(OS2_HEAD *Header);
69	ILboolean iLoadBitmapInternal(ILvoid);	69	ILboolean iLoadBitmapInternal(void);
70	ILboolean iSaveBitmapInternal(ILvoid);	70	ILboolean iSaveBitmapInternal(void);
71	ILboolean ilReadUncompBmp(BMPHEAD *Info);	71	ILboolean ilReadUncompBmp(BMPHEAD *Info);
72	ILboolean ilReadRLE8Bmp(BMPHEAD *Info);	72	ILboolean ilReadRLE8Bmp(BMPHEAD *Info);
73	ILboolean ilReadRLE4Bmp(BMPHEAD *Info);	73	ILboolean ilReadRLE4Bmp(BMPHEAD *Info);

Lines 43-51 typedef struct DCXHEAD Link Here

(-)DevIL-1.6.7/src-IL/include/il_dcx.h (-2 / +2 lines)
43	#endif	43	#endif
44		44
45	// For checking and reading	45	// For checking and reading
46	ILboolean iIsValidDcx(ILvoid);	46	ILboolean iIsValidDcx(void);
47	ILboolean iCheckDcx(DCXHEAD *Header);	47	ILboolean iCheckDcx(DCXHEAD *Header);
48	ILboolean iLoadDcxInternal(ILvoid);	48	ILboolean iLoadDcxInternal(void);
49	ILimage* iUncompressDcx(DCXHEAD *Header);	49	ILimage* iUncompressDcx(DCXHEAD *Header);
50	ILimage* iUncompressDcxSmall(DCXHEAD *Header);	50	ILimage* iUncompressDcxSmall(DCXHEAD *Header);
51		51




#define CUBEMAP_SIDES 6

// Internal functions
ILboolean	iLoadDdsInternal(void);
ILboolean	iIsValidDds(void);
ILboolean	iCheckDds(DDSHEAD *Head);
ILvoid		AdjustVolumeTexture(DDSHEAD *Head);
ILboolean	ReadData(void);
ILboolean	AllocImage(void);
ILboolean	Decompress(void);
ILboolean	ReadMipmaps(void);
ILvoid		DecodePixelFormat(void);
ILboolean	DecompressARGB(void);
ILboolean	DecompressDXT1(void);
ILboolean	DecompressDXT2(void);
ILboolean	DecompressDXT3(void);
ILboolean	DecompressDXT4(void);
ILboolean	DecompressDXT5(void);
ILboolean	Decompress3Dc(void);
ILvoid		CorrectPreMult(void);
ILvoid		GetBitsFromMask(ILuint Mask, ILuint *ShiftLeft, ILuint *ShiftRight);
ILboolean	iSaveDdsInternal(void);
ILboolean	WriteHeader(ILimage *Image, ILenum DXTCFormat);
ILushort	*CompressTo565(ILimage *Image);
ILubyte		*CompressTo88(ILimage *Image);




//	((f>>8) & 0xff000000) | ((f<<8) & 0xff00000000) | ((f<<24) & 0xff0000000000) | ((f<<40) & 0xff000000000000) | (f<<56))


ILushort	GetLittleUShort(void);
ILshort		GetLittleShort(void);
ILuint		GetLittleUInt(void);
ILint		GetLittleInt(void);
ILfloat		GetLittleFloat(void);
ILdouble	GetLittleDouble(void);
ILushort	GetBigUShort(void);
ILshort		GetBigShort(void);
ILuint		GetBigUInt(void);
ILint		GetBigInt(void);
ILfloat		GetBigFloat(void);
ILdouble	GetBigDouble(void);

ILubyte		SaveLittleUShort(ILushort _s);
ILubyte		SaveLittleShort(ILshort _s);




#include <IL/il.h>


__FILES_EXTERN ILvoid ILAPIENTRY iPreserveReadFuncs(void);
__FILES_EXTERN ILvoid ILAPIENTRY iRestoreReadFuncs(void);

__FILES_EXTERN fEofProc		EofProc;
__FILES_EXTERN fGetcProc	GetcProc;


__FILES_EXTERN ILvoid		iSetInputFile(ILHANDLE File);
__FILES_EXTERN ILvoid		iSetInputLump(ILvoid *Lump, ILuint Size);
__FILES_EXTERN ILboolean	(ILAPIENTRY *ieof)(void);
__FILES_EXTERN ILHANDLE		(ILAPIENTRY *iopenr)(const ILstring);
__FILES_EXTERN ILvoid		(ILAPIENTRY *icloser)(ILHANDLE);
__FILES_EXTERN ILint		(ILAPIENTRY *igetc)(void);
__FILES_EXTERN ILuint		(ILAPIENTRY *iread)(ILvoid *Buffer, ILuint Size, ILuint Number);
__FILES_EXTERN ILuint		(ILAPIENTRY *iseek)(ILint Offset, ILuint Mode);
__FILES_EXTERN ILuint		(ILAPIENTRY *itell)(void);

__FILES_EXTERN ILvoid		iSetOutputFile(ILHANDLE File);
__FILES_EXTERN ILvoid		iSetOutputLump(ILvoid *Lump, ILuint Size);

__FILES_EXTERN ILHANDLE		(ILAPIENTRY *iopenw)(const ILstring);
__FILES_EXTERN ILint		(ILAPIENTRY *iputc)(ILubyte Char);
__FILES_EXTERN ILuint		(ILAPIENTRY *iseekw)(ILint Offset, ILuint Mode);
__FILES_EXTERN ILuint		(ILAPIENTRY *itellw)(void);
__FILES_EXTERN ILint		(ILAPIENTRY *iwrite)(const ILvoid *Buffer, ILuint Size, ILuint Number);
 
__FILES_EXTERN ILHANDLE		ILAPIENTRY iGetFile(void);
__FILES_EXTERN ILubyte*		ILAPIENTRY iGetLump(void);

__FILES_EXTERN ILuint		ILAPIENTRY ilprintf(const char *, ...);
__FILES_EXTERN ILvoid		ipad(ILuint NumZeros);

__FILES_EXTERN ILboolean	iPreCache(ILuint Size);
__FILES_EXTERN ILvoid		iUnCache(void);

#endif//FILES_H

Lines 57-65 typedef struct GFXCONTROL Link Here

(-)DevIL-1.6.7/src-IL/include/il_gif.h (-2 / +2 lines)
57	#endif	57	#endif
58		58
59	// Internal functions	59	// Internal functions
60	ILboolean iLoadGifInternal(ILvoid);	60	ILboolean iLoadGifInternal(void);
61	ILboolean ilLoadGifF(ILHANDLE File);	61	ILboolean ilLoadGifF(ILHANDLE File);
62	ILboolean iIsValidGif(ILvoid);	62	ILboolean iIsValidGif(void);
63	ILboolean iGetPalette(ILubyte Info, ILpal *Pal);	63	ILboolean iGetPalette(ILubyte Info, ILpal *Pal);
64	ILboolean GetImages(ILpal GlobalPal, GIFHEAD GifHead);	64	ILboolean GetImages(ILpal GlobalPal, GIFHEAD GifHead);
65	ILboolean SkipExtensions(GFXCONTROL *Gfx);	65	ILboolean SkipExtensions(GFXCONTROL *Gfx);






// Miscellaneous functions
ILvoid					ilDefaultStates(void);
ILenum					iGetHint(ILenum Target);
ILint					iGetInt(ILenum Mode);
ILvoid					ilRemoveRegistered(void);
ILAPI ILvoid ILAPIENTRY	ilSetCurImage(ILimage *Image);



ILboolean	ilRleCompressLine(ILubyte *ScanLine, ILuint Width, ILubyte Bpp, ILubyte *Dest, ILuint *DestWidth, ILenum CompressMode);
ILuint		ilRleCompress(ILubyte *Data, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILubyte *Dest, ILenum CompressMode, ILuint *ScanTable);

ILvoid		iSetImage0(void);


// Conversion functions
ILboolean	ilAddAlpha(void);
ILboolean	ilAddAlphaKey(ILimage *Image);
ILboolean	iFastConvert(ILenum DestFormat);
ILboolean	ilFixImage(void);
ILboolean	ilRemoveAlpha(void);
ILboolean	ilSwapColours(void);


// Miscellaneous functions

Lines 16-26 Link Here

(-)DevIL-1.6.7/src-IL/include/il_jpeg.h (-3 / +3 lines)
16	#include "il_internal.h"	16	#include "il_internal.h"
17		17
18	ILboolean iCheckJpg(ILubyte Header[2]);	18	ILboolean iCheckJpg(ILubyte Header[2]);
19	ILboolean iIsValidJpg(ILvoid);	19	ILboolean iIsValidJpg(void);
20		20
21	#ifndef IL_USE_IJL	21	#ifndef IL_USE_IJL
22	ILboolean iLoadJpegInternal(ILvoid);	22	ILboolean iLoadJpegInternal(void);
23	ILboolean iSaveJpegInternal(ILvoid);	23	ILboolean iSaveJpegInternal(void);
24	#else	24	#else
25	ILboolean iLoadJpegInternal(const ILstring FileName, ILvoid *Lump, ILuint Size);	25	ILboolean iLoadJpegInternal(const ILstring FileName, ILvoid *Lump, ILuint Size);
26	ILboolean iSaveJpegInternal(const ILstring FileName, ILvoid *Lump, ILuint Size);	26	ILboolean iSaveJpegInternal(const ILstring FileName, ILvoid *Lump, ILuint Size);

Lines 30-37 typedef struct LIF_HEAD Link Here

(-)DevIL-1.6.7/src-IL/include/il_lif.h (-2 / +2 lines)
30	ILuint TeamEffect1; // Team effect offset 1	30	ILuint TeamEffect1; // Team effect offset 1
31	} LIF_HEAD;	31	} LIF_HEAD;
32		32
33	ILboolean iIsValidLif(ILvoid);	33	ILboolean iIsValidLif(void);
34	ILboolean iCheckLif(LIF_HEAD *Header);	34	ILboolean iCheckLif(LIF_HEAD *Header);
35	ILboolean iLoadLifInternal(ILvoid);	35	ILboolean iLoadLifInternal(void);
36		36
37	#endif//LIF_H	37	#endif//LIF_H

Lines 13-19 Link Here

(-)DevIL-1.6.7/src-IL/include/il_manip.h (-2 / +2 lines)
13	#ifndef MANIP_H	13	#ifndef MANIP_H
14	#define MANIP_H	14	#define MANIP_H
15		15
16	ILboolean ilFlipImage(ILvoid);	16	ILboolean ilFlipImage(void);
17	ILboolean ilMirrorImage(ILvoid); //@JASON New routine created 03/28/2001	17	ILboolean ilMirrorImage(void); //@JASON New routine created 03/28/2001
18		18
19	#endif//MANIP_H	19	#endif//MANIP_H

Lines 43-52 typedef struct PCXHEAD Link Here

(-)DevIL-1.6.7/src-IL/include/il_pcx.h (-3 / +3 lines)
43	#endif	43	#endif
44		44
45	// For checking and reading	45	// For checking and reading
46	ILboolean iIsValidPcx(ILvoid);	46	ILboolean iIsValidPcx(void);
47	ILboolean iCheckPcx(PCXHEAD *Header);	47	ILboolean iCheckPcx(PCXHEAD *Header);
48	ILboolean iLoadPcxInternal(ILvoid);	48	ILboolean iLoadPcxInternal(void);
49	ILboolean iSavePcxInternal(ILvoid);	49	ILboolean iSavePcxInternal(void);
50	ILboolean iUncompressPcx(PCXHEAD *Header);	50	ILboolean iUncompressPcx(PCXHEAD *Header);
51	ILboolean iUncompressSmall(PCXHEAD *Header);	51	ILboolean iUncompressSmall(PCXHEAD *Header);
52		52

Lines 65-73 typedef struct CHANNEL Link Here

(-)DevIL-1.6.7/src-IL/include/il_pic.h (-2 / +2 lines)
65	#define PIC_AUXILIARY_1_CHANNEL 0x02 // XXX: Not implemented	65	#define PIC_AUXILIARY_1_CHANNEL 0x02 // XXX: Not implemented
66	#define PIC_AUXILIARY_2_CHANNEL 0x01 // XXX: Not implemented	66	#define PIC_AUXILIARY_2_CHANNEL 0x01 // XXX: Not implemented
67		67
68	ILboolean iIsValidPic(ILvoid);	68	ILboolean iIsValidPic(void);
69	ILboolean iCheckPic(PIC_HEAD *Header);	69	ILboolean iCheckPic(PIC_HEAD *Header);
70	ILboolean iLoadPicInternal(ILvoid);	70	ILboolean iLoadPicInternal(void);
71	ILboolean readScanlines(ILuint image, ILint width, ILint height, CHANNEL channel, ILuint alpha);	71	ILboolean readScanlines(ILuint image, ILint width, ILint height, CHANNEL channel, ILuint alpha);
72	ILuint readScanline(ILubyte scan, ILint width, CHANNEL channel, ILint bytes);	72	ILuint readScanline(ILubyte scan, ILint width, CHANNEL channel, ILint bytes);
73	ILboolean channelReadRaw(ILubyte scan, ILint width, ILint noCol, ILint off, ILint bytes);	73	ILboolean channelReadRaw(ILubyte scan, ILint width, ILint noCol, ILint off, ILint bytes);




	ILubyte	Bpp;
} PPMINFO;

ILboolean	iIsValidPnm(void);
ILboolean	iCheckPnm(char Header[2]);
ILboolean	iLoadPnmInternal(void);
ILboolean	iSavePnmInternal(void);
ILimage		*ilReadAsciiPpm(PPMINFO *Info);
ILimage		*ilReadBinaryPpm(PPMINFO *Info);
ILimage		*ilReadBitPbm(PPMINFO *Info);
ILboolean	iGetWord(void);
ILvoid		PbmMaximize(ILimage *Image);







ILushort	ChannelNum;

ILboolean	iIsValidPsd(void);
ILboolean	iCheckPsd(PSDHEAD *Header);
ILboolean	iLoadPsdInternal(void);
ILboolean	ReadPsd(PSDHEAD *Head);
ILboolean	ReadGrey(PSDHEAD *Head);
ILboolean	ReadIndexed(PSDHEAD *Head);

ILboolean	PsdGetData(PSDHEAD *Head, ILvoid *Buffer, ILboolean Compressed);
ILboolean	ParseResources(ILuint ResourceSize, ILubyte *Resources);
ILboolean	GetSingleChannel(PSDHEAD *Head, ILubyte *Buffer, ILboolean Compressed);
ILboolean	iSavePsdInternal(void);









// Function definitions
ILboolean	iLoadPspInternal(void);
ILboolean	iCheckPsp(void);
ILboolean	iIsValidPsp(void);
ILboolean	ReadGenAttributes(void);
ILboolean	ParseChunks(void);
ILboolean	ReadLayerBlock(ILuint BlockLen);
ILboolean	ReadAlphaBlock(ILuint BlockLen);
ILubyte		*GetChannel(void);
ILboolean	UncompRLE(ILubyte *CompData, ILubyte *Data, ILuint CompLen);
ILboolean	ReadPalette(ILuint BlockLen);
ILboolean	AssembleImage(void);
ILboolean	Cleanup(void);




Lines 46-55 typedef struct iSgiHeader Link Here

(-)DevIL-1.6.7/src-IL/include/il_sgi.h (-3 / +3 lines)
46		46
47		47
48	// Internal functions	48	// Internal functions
49	ILboolean iIsValidSgi(ILvoid);	49	ILboolean iIsValidSgi(void);
50	ILboolean iCheckSgi(iSgiHeader *Header);	50	ILboolean iCheckSgi(iSgiHeader *Header);
51	ILboolean iLoadSgiInternal(ILvoid);	51	ILboolean iLoadSgiInternal(void);
52	ILboolean iSaveSgiInternal(ILvoid);	52	ILboolean iSaveSgiInternal(void);
53	ILvoid iExpandScanLine(ILubyte Dest, ILubyte Src, ILuint Bpc);	53	ILvoid iExpandScanLine(ILubyte Dest, ILubyte Src, ILuint Bpc);
54	ILint iGetScanLine(ILubyte ScanLine, iSgiHeader Head, ILuint Length);	54	ILint iGetScanLine(ILubyte ScanLine, iSgiHeader Head, ILuint Length);
55	ILint iGetScanLineFast(ILubyte ScanLine, iSgiHeader Head, ILuint Length, ILubyte*);	55	ILint iGetScanLineFast(ILubyte ScanLine, iSgiHeader Head, ILuint Length, ILubyte*);

Lines 27-34 typedef struct iFree Link Here

(-)DevIL-1.6.7/src-IL/include/il_stack.h (-2 / +2 lines)
27		27
28		28
29	// Internal functions	29	// Internal functions
30	ILboolean iEnlargeStack(ILvoid);	30	ILboolean iEnlargeStack(void);
31	ILvoid iFreeMem(ILvoid);	31	ILvoid iFreeMem(void);
32		32
33	// Globals for il_stack.c	33	// Globals for il_stack.c
34	ILuint StackSize = 0;	34	ILuint StackSize = 0;

Lines 98-105 typedef struct TARGAEXT Link Here

(-)DevIL-1.6.7/src-IL/include/il_targa.h (-2 / +2 lines)
98	ILboolean iIsValidTarga();	98	ILboolean iIsValidTarga();
99	ILboolean iGetTgaHead(TARGAHEAD *Header);	99	ILboolean iGetTgaHead(TARGAHEAD *Header);
100	ILboolean iCheckTarga(TARGAHEAD *Header);	100	ILboolean iCheckTarga(TARGAHEAD *Header);
101	ILboolean iLoadTargaInternal(ILvoid);	101	ILboolean iLoadTargaInternal(void);
102	ILboolean iSaveTargaInternal(ILvoid);	102	ILboolean iSaveTargaInternal(void);
103	//ILvoid iMakeString(char *Str);	103	//ILvoid iMakeString(char *Str);
104	ILboolean iReadBwTga(TARGAHEAD *Header);	104	ILboolean iReadBwTga(TARGAHEAD *Header);
105	ILboolean iReadColMapTga(TARGAHEAD *Header);	105	ILboolean iReadColMapTga(TARGAHEAD *Header);

Lines 18-25 Link Here

(-)DevIL-1.6.7/src-IL/src/il_doom.c (-2 / +2 lines)
18	#include "il_doompal.h"	18	#include "il_doompal.h"
19		19
20		20
21	ILboolean iLoadDoomInternal(ILvoid);	21	ILboolean iLoadDoomInternal(void);
22	ILboolean iLoadDoomFlatInternal(ILvoid);	22	ILboolean iLoadDoomFlatInternal(void);
23		23
24		24
25	//	25	//

Lines 41-47 ILAPI ILvoid ILAPIENTRY ilSetError(ILenu Link Here

(-)DevIL-1.6.7/src-IL/src/il_error.c (-1 / +1 lines)
41		41
42		42
43	//! Gets the last error on the error stack	43	//! Gets the last error on the error stack
44	ILenum ILAPIENTRY ilGetError(ILvoid)	44	ILenum ILAPIENTRY ilGetError(void)
45	{	45	{
46	ILenum ilReturn;	46	ILenum ilReturn;
47		47






// All specific to the next set of functions
ILboolean	ILAPIENTRY iEofFile(void);
ILboolean	ILAPIENTRY iEofLump(void);
ILint		ILAPIENTRY iGetcFile(void);
ILint		ILAPIENTRY iGetcLump(void);
ILuint		ILAPIENTRY iReadFile(ILvoid *Buffer, ILuint Size, ILuint Number);
ILuint		ILAPIENTRY iReadLump(ILvoid *Buffer, ILuint Size, ILuint Number);
ILuint		ILAPIENTRY iSeekRFile(ILint Offset, ILuint Mode);
ILuint		ILAPIENTRY iSeekRLump(ILint Offset, ILuint Mode);
ILuint		ILAPIENTRY iSeekWFile(ILint Offset, ILuint Mode);
ILuint		ILAPIENTRY iSeekWLump(ILint Offset, ILuint Mode);
ILuint		ILAPIENTRY iTellRFile(void);
ILuint		ILAPIENTRY iTellRLump(void);
ILuint		ILAPIENTRY iTellWFile(void);
ILuint		ILAPIENTRY iTellWLump(void);
ILint		ILAPIENTRY iPutcFile(ILubyte Char);
ILint		ILAPIENTRY iPutcLump(ILubyte Char);
ILint		ILAPIENTRY iWriteFile(const ILvoid *Buffer, ILuint Size, ILuint Number);


// Next 12 functions are the default write functions

ILboolean ILAPIENTRY iEofFile(void)
{
	return EofProc((FILE*)FileRead);
}


ILboolean ILAPIENTRY iEofLump(void)
{
	if (ReadLumpSize)
		return (ReadLumpPos >= ReadLumpSize);

}


ILint ILAPIENTRY iGetcFile(void)
{
	if (!UseCache) {
		return GetcProc(FileRead);

}


ILint ILAPIENTRY iGetcLump(void)
{
	// If ReadLumpSize is 0, don't even check to see if we've gone past the bounds.
	if (ReadLumpSize > 0) {

}


ILuint ILAPIENTRY iTellRFile(void)
{
	return TellRProc(FileRead);
}


ILuint ILAPIENTRY iTellRLump(void)
{
	return ReadLumpPos;
}


ILHANDLE ILAPIENTRY iGetFile(void)
{
	return FileRead;
}


ILubyte* ILAPIENTRY iGetLump(void)
{
	return ReadLump;
}

}


ILuint ILAPIENTRY iTellWFile(void)
{
	return TellWProc(FileWrite);
}


ILuint ILAPIENTRY iTellWLump(void)
{
	return WriteLumpPos;
}

Lines 519-525 ILboolean iSaveJpegInternal() Link Here

(-)DevIL-1.6.7/src-IL/src/il_jpeg.c (-2 / +2 lines)
519	// Here the array is only one element long, but you could pass	519	// Here the array is only one element long, but you could pass
520	// more than one scanline at a time if that's more convenient.	520	// more than one scanline at a time if that's more convenient.
521	row_pointer[0] = &TempData[JpegInfo.next_scanline * TempImage->Bps];	521	row_pointer[0] = &TempData[JpegInfo.next_scanline * TempImage->Bps];
522	(ILvoid) jpeg_write_scanlines(&JpegInfo, row_pointer, 1);	522	(void) jpeg_write_scanlines(&JpegInfo, row_pointer, 1);
523	}	523	}
524		524
525	// Step 6: Finish compression	525	// Step 6: Finish compression
Lines 933-939 ILboolean ILAPIENTRY ilSaveFromJpegStruc Link Here
933	// Here the array is only one element long, but you could pass	933	// Here the array is only one element long, but you could pass
934	// more than one scanline at a time if that's more convenient.	934	// more than one scanline at a time if that's more convenient.
935	row_pointer[0] = &TempData[JpegInfo->next_scanline * TempImage->Bps];	935	row_pointer[0] = &TempData[JpegInfo->next_scanline * TempImage->Bps];
936	(ILvoid) jpeg_write_scanlines(JpegInfo, row_pointer, 1);	936	(void) jpeg_write_scanlines(JpegInfo, row_pointer, 1);
937	}	937	}
938		938
939	if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT)	939	if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT)

Lines 16-22 Link Here

(-)DevIL-1.6.7/src-IL/src/il_mdl.c (-1 / +1 lines)
16	#include "il_mdl.h"	16	#include "il_mdl.h"
17		17
18		18
19	ILboolean iLoadMdlInternal(ILvoid);	19	ILboolean iLoadMdlInternal(void);
20		20
21		21
22	//! Reads a .Mdl file	22	//! Reads a .Mdl file

Lines 175-181 mng_bool MNG_DECL mymngerror( Link Here

(-)DevIL-1.6.7/src-IL/src/il_mng.c (-2 / +2 lines)
175	}	175	}
176		176
177		177
178	ILboolean iLoadMngInternal(ILvoid);	178	ILboolean iLoadMngInternal(void);
179		179
180	// Reads a file	180	// Reads a file
181	ILboolean ilLoadMng(const ILstring FileName)	181	ILboolean ilLoadMng(const ILstring FileName)
Lines 257-263 ILboolean iLoadMngInternal() Link Here
257	}	257	}
258		258
259		259
260	ILboolean iSaveMngInternal(ILvoid);	260	ILboolean iSaveMngInternal(void);
261		261
262	//! Writes a Mng file	262	//! Writes a Mng file
263	ILboolean ilSaveMng(const ILstring FileName)	263	ILboolean ilSaveMng(const ILstring FileName)

Lines 18-24 Link Here

(-)DevIL-1.6.7/src-IL/src/il_pcd.c (-1 / +1 lines)
18	#include "il_manip.h"	18	#include "il_manip.h"
19		19
20		20
21	ILboolean iLoadPcdInternal(ILvoid);	21	ILboolean iLoadPcdInternal(void);
22		22
23	//! Reads a .pcd file	23	//! Reads a .pcd file
24	ILboolean ilLoadPcd(const ILstring FileName)	24	ILboolean ilLoadPcd(const ILstring FileName)

Lines 243-249 ILboolean readScanlines(ILuint *image, I Link Here

(-)DevIL-1.6.7/src-IL/src/il_pic.c (-1 / +1 lines)
243	ILint i;	243	ILint i;
244	ILuint *scan;	244	ILuint *scan;
245		245
246	(ILvoid)alpha;	246	(void)alpha;
247		247
248	for (i = height - 1; i >= 0; i--) {	248	for (i = height - 1; i >= 0; i--) {
249	scan = image + i * width;	249	scan = image + i * width;

Lines 33-39 typedef struct PIXHEAD Link Here

(-)DevIL-1.6.7/src-IL/src/il_pix.c (-1 / +1 lines)
33	#endif	33	#endif
34		34
35	ILboolean iCheckPix(PIXHEAD *Header);	35	ILboolean iCheckPix(PIXHEAD *Header);
36	ILboolean iLoadPixInternal(ILvoid);	36	ILboolean iLoadPixInternal(void);
37		37
38		38
39	// Internal function used to get the Pix header from the current file.	39	// Internal function used to get the Pix header from the current file.




	#warning DevIL was designed with libpng 1.2.0 or higher in mind.  Consider upgrading at www.libpng.org
#endif

ILboolean	iIsValidPng(void);
ILboolean	iLoadPngInternal(void);
ILboolean	iSavePngInternal(void);
ILvoid		pngSwitchData(ILubyte *Data, ILuint SizeOfData, ILubyte Bpc);

ILint		readpng_init(void);
ILboolean	readpng_get_image(ILdouble display_exponent);
ILvoid		readpng_cleanup(void);

png_structp png_ptr = NULL;
png_infop info_ptr = NULL;


static ILvoid png_read(png_structp png_ptr, png_bytep data, png_size_t length)
{
	(void)png_ptr;
	iread(data, 1, length);
	return;
}


ILvoid png_write(png_structp png_ptr, png_bytep data, png_size_t length)
{
	(void)png_ptr;
	iwrite(data, 1, length);
	return;
}

Lines 407-413 ILimage ilReadBitPbm(PPMINFO Info) Link Here

(-)DevIL-1.6.7/src-IL/src/il_pnm.c (-1 / +1 lines)
407	}	407	}
408		408
409		409
410	ILboolean iGetWord(ILvoid)	410	ILboolean iGetWord(void)
411	{	411	{
412	ILint WordPos = 0;	412	ILint WordPos = 0;
413	ILint Current = 0;	413	ILint Current = 0;

Lines 34-40 typedef struct PIXHEAD Link Here

(-)DevIL-1.6.7/src-IL/src/il_pxr.c (-1 / +1 lines)
34	#pragma pack(pop, pxr_struct)	34	#pragma pack(pop, pxr_struct)
35	#endif	35	#endif
36		36
37	ILboolean iLoadPxrInternal(ILvoid);	37	ILboolean iLoadPxrInternal(void);
38		38
39		39
40	//! Reads a Pxr file	40	//! Reads a Pxr file

Lines 15-22 Link Here

(-)DevIL-1.6.7/src-IL/src/il_raw.c (-2 / +2 lines)
15	#ifndef IL_NO_RAW	15	#ifndef IL_NO_RAW
16		16
17		17
18	ILboolean iLoadRawInternal(ILvoid);	18	ILboolean iLoadRawInternal(void);
19	ILboolean iSaveRawInternal(ILvoid);	19	ILboolean iSaveRawInternal(void);
20		20
21		21
22	//! Reads a raw file	22	//! Reads a raw file

Lines 308-314 ILboolean ILAPIENTRY ilGetBoolean(ILenum Link Here

(-)DevIL-1.6.7/src-IL/src/il_states.c (-1 / +1 lines)
308	}	308	}
309		309
310		310
311	ILimage *iGetBaseImage(ILvoid);	311	ILimage *iGetBaseImage(void);
312		312
313	ILuint iGetActiveNum(ILenum Type)	313	ILuint iGetActiveNum(ILenum Type)
314	{	314	{

Lines 308-314 ILboolean ILAPIENTRY ilGetBoolean(ILenum Link Here

(-)DevIL-1.6.7/src-IL/src/.#il_states.c.1.34 (-1 / +1 lines)
308	}	308	}
309		309
310		310
311	ILimage *iGetBaseImage(ILvoid);	311	ILimage *iGetBaseImage(void);
312		312
313	ILuint iGetActiveNum(ILenum Type)	313	ILuint iGetActiveNum(ILenum Type)
314	{	314	{

Lines 25-32 Link Here

(-)DevIL-1.6.7/src-IL/src/il_tiff.c (-2 / +2 lines)
25	/----------------------------------------------------------------------------/	25	/----------------------------------------------------------------------------/
26		26
27	// No need for a separate header	27	// No need for a separate header
28	static ILboolean iLoadTiffInternal(ILvoid);	28	static ILboolean iLoadTiffInternal(void);
29	static char* iMakeString(ILvoid);	29	static char* iMakeString(void);
30	static TIFF* iTIFFOpen(char *Mode);	30	static TIFF* iTIFFOpen(char *Mode);
31	static ILboolean iSaveTiffInternal(char *Filename);	31	static ILboolean iSaveTiffInternal(char *Filename);
32		32

Lines 29-35 typedef struct WALHEAD Link Here

(-)DevIL-1.6.7/src-IL/src/il_wal.c (-1 / +1 lines)
29	ILuint Value; // ??	29	ILuint Value; // ??
30	} WALHEAD;	30	} WALHEAD;
31		31
32	ILboolean iLoadWalInternal(ILvoid);	32	ILboolean iLoadWalInternal(void);
33		33
34		34
35	//! Reads a .wal file	35	//! Reads a .wal file

Lines 16-22 Link Here

(-)DevIL-1.6.7/src-IL/src/il_xpm.c (-1 / +1 lines)
16	#include <ctype.h>	16	#include <ctype.h>
17		17
18		18
19	ILboolean iLoadXpmInternal(ILvoid);	19	ILboolean iLoadXpmInternal(void);
20		20
21		21
22	// Reads an .xpm file	22	// Reads an .xpm file

Lines 82-88 ILfloat ilCos(ILfloat Angle); Link Here

(-)DevIL-1.6.7/src-ILU/include/ilu_internal.h (-1 / +1 lines)
82	ILfloat ilSin(ILfloat Angle);	82	ILfloat ilSin(ILfloat Angle);
83	ILint ilRound(ILfloat Num);	83	ILint ilRound(ILfloat Num);
84	ILuint iluScaleAdvanced(ILuint Width, ILuint Height, ILenum Filter);	84	ILuint iluScaleAdvanced(ILuint Width, ILuint Height, ILenum Filter);
85	ILubyte *iScanFill(ILvoid);	85	ILubyte *iScanFill(void);
86		86
87		87
88	#endif//INTERNAL_H	88	#endif//INTERNAL_H

Lines 1060-1066 ILboolean ILAPIENTRY iluSaturate4f(ILflo Link Here

(-)DevIL-1.6.7/src-ILU/src/ilu_filter.c (-1 / +1 lines)
1060		1060
1061		1061
1062	//! Funny as hell filter that I stumbled upon accidentally	1062	//! Funny as hell filter that I stumbled upon accidentally
1063	ILboolean ILAPIENTRY iluAlienify(ILvoid)	1063	ILboolean ILAPIENTRY iluAlienify(void)
1064	{	1064	{
1065	ILfloat Mat[3][3];	1065	ILfloat Mat[3][3];
1066	ILubyte *Data;	1066	ILubyte *Data;

Lines 1070-1076 ILboolean ILAPIENTRY iluSaturate4f(ILflo Link Here

(-)DevIL-1.6.7/src-ILU/src/.#ilu_filter.c.1.8 (-1 / +1 lines)
1070		1070
1071		1071
1072	//! Funny as hell filter that I stumbled upon accidentally	1072	//! Funny as hell filter that I stumbled upon accidentally
1073	ILboolean ILAPIENTRY iluAlienify(ILvoid)	1073	ILboolean ILAPIENTRY iluAlienify(void)
1074	{	1074	{
1075	ILfloat Mat[3][3];	1075	ILfloat Mat[3][3];
1076	ILubyte *Data;	1076	ILubyte *Data;

Lines 43-49 Link Here

(-)DevIL-1.6.7/src-ILUT/include/ilut_internal.h (-1 / +1 lines)
43	extern ILimage *ilutCurImage;	43	extern ILimage *ilutCurImage;
44		44
45		45
46	ILvoid ilutDefaultStates(ILvoid);	46	ILvoid ilutDefaultStates(void);
47		47
48		48
49	// ImageLib Utility Toolkit's OpenGL Functions	49	// ImageLib Utility Toolkit's OpenGL Functions

Return to bug 179843

Lines 163-187 extern ILuint BlockSize; Link Here

(-)DevIL-1.6.7/src-IL/include/il_dds.h (-16 / +16 lines)
163	#define CUBEMAP_SIDES 6	163	#define CUBEMAP_SIDES 6
164		164
165	// Internal functions	165	// Internal functions
166	ILboolean iLoadDdsInternal(ILvoid);	166	ILboolean iLoadDdsInternal(void);
167	ILboolean iIsValidDds(ILvoid);	167	ILboolean iIsValidDds(void);
168	ILboolean iCheckDds(DDSHEAD *Head);	168	ILboolean iCheckDds(DDSHEAD *Head);
169	ILvoid AdjustVolumeTexture(DDSHEAD *Head);	169	ILvoid AdjustVolumeTexture(DDSHEAD *Head);
170	ILboolean ReadData(ILvoid);	170	ILboolean ReadData(void);
171	ILboolean AllocImage(ILvoid);	171	ILboolean AllocImage(void);
172	ILboolean Decompress(ILvoid);	172	ILboolean Decompress(void);
173	ILboolean ReadMipmaps(ILvoid);	173	ILboolean ReadMipmaps(void);
174	ILvoid DecodePixelFormat(ILvoid);	174	ILvoid DecodePixelFormat(void);
175	ILboolean DecompressARGB(ILvoid);	175	ILboolean DecompressARGB(void);
176	ILboolean DecompressDXT1(ILvoid);	176	ILboolean DecompressDXT1(void);
177	ILboolean DecompressDXT2(ILvoid);	177	ILboolean DecompressDXT2(void);
178	ILboolean DecompressDXT3(ILvoid);	178	ILboolean DecompressDXT3(void);
179	ILboolean DecompressDXT4(ILvoid);	179	ILboolean DecompressDXT4(void);
180	ILboolean DecompressDXT5(ILvoid);	180	ILboolean DecompressDXT5(void);
181	ILboolean Decompress3Dc(ILvoid);	181	ILboolean Decompress3Dc(void);
182	ILvoid CorrectPreMult(ILvoid);	182	ILvoid CorrectPreMult(void);
183	ILvoid GetBitsFromMask(ILuint Mask, ILuint ShiftLeft, ILuint ShiftRight);	183	ILvoid GetBitsFromMask(ILuint Mask, ILuint ShiftLeft, ILuint ShiftRight);
184	ILboolean iSaveDdsInternal(ILvoid);	184	ILboolean iSaveDdsInternal(void);
185	ILboolean WriteHeader(ILimage *Image, ILenum DXTCFormat);	185	ILboolean WriteHeader(ILimage *Image, ILenum DXTCFormat);
186	ILushort CompressTo565(ILimage Image);	186	ILushort CompressTo565(ILimage Image);
187	ILubyte CompressTo88(ILimage Image);	187	ILubyte CompressTo88(ILimage Image);

Lines 162-171 ILuint ilStrLen(const char *Str); Link Here

(-)DevIL-1.6.7/src-IL/include/il_internal.h (-7 / +7 lines)
162		162
163		163
164	// Miscellaneous functions	164	// Miscellaneous functions
165	ILvoid ilDefaultStates(ILvoid);	165	ILvoid ilDefaultStates(void);
166	ILenum iGetHint(ILenum Target);	166	ILenum iGetHint(ILenum Target);
167	ILint iGetInt(ILenum Mode);	167	ILint iGetInt(ILenum Mode);
168	ILvoid ilRemoveRegistered(ILvoid);	168	ILvoid ilRemoveRegistered(void);
169	ILAPI ILvoid ILAPIENTRY ilSetCurImage(ILimage *Image);	169	ILAPI ILvoid ILAPIENTRY ilSetCurImage(ILimage *Image);
170		170
171		171
Lines 178-193 ILAPI ILvoid ILAPIENTRY ilSetCurImage(IL Link Here
178	ILboolean ilRleCompressLine(ILubyte ScanLine, ILuint Width, ILubyte Bpp, ILubyte Dest, ILuint *DestWidth, ILenum CompressMode);	178	ILboolean ilRleCompressLine(ILubyte ScanLine, ILuint Width, ILubyte Bpp, ILubyte Dest, ILuint *DestWidth, ILenum CompressMode);
179	ILuint ilRleCompress(ILubyte Data, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILubyte Dest, ILenum CompressMode, ILuint *ScanTable);	179	ILuint ilRleCompress(ILubyte Data, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILubyte Dest, ILenum CompressMode, ILuint *ScanTable);
180		180
181	ILvoid iSetImage0(ILvoid);	181	ILvoid iSetImage0(void);
182		182
183		183
184	// Conversion functions	184	// Conversion functions
185	ILboolean ilAddAlpha(ILvoid);	185	ILboolean ilAddAlpha(void);
186	ILboolean ilAddAlphaKey(ILimage *Image);	186	ILboolean ilAddAlphaKey(ILimage *Image);
187	ILboolean iFastConvert(ILenum DestFormat);	187	ILboolean iFastConvert(ILenum DestFormat);
188	ILboolean ilFixImage(ILvoid);	188	ILboolean ilFixImage(void);
189	ILboolean ilRemoveAlpha(ILvoid);	189	ILboolean ilRemoveAlpha(void);
190	ILboolean ilSwapColours(ILvoid);	190	ILboolean ilSwapColours(void);
191		191
192		192
193	// Miscellaneous functions	193	// Miscellaneous functions

Lines 17-36 Link Here

(-)DevIL-1.6.7/src-IL/src/il_files.c (-18 / +18 lines)
17		17
18		18
19	// All specific to the next set of functions	19	// All specific to the next set of functions
20	ILboolean ILAPIENTRY iEofFile(ILvoid);	20	ILboolean ILAPIENTRY iEofFile(void);
21	ILboolean ILAPIENTRY iEofLump(ILvoid);	21	ILboolean ILAPIENTRY iEofLump(void);
22	ILint ILAPIENTRY iGetcFile(ILvoid);	22	ILint ILAPIENTRY iGetcFile(void);
23	ILint ILAPIENTRY iGetcLump(ILvoid);	23	ILint ILAPIENTRY iGetcLump(void);
24	ILuint ILAPIENTRY iReadFile(ILvoid *Buffer, ILuint Size, ILuint Number);	24	ILuint ILAPIENTRY iReadFile(ILvoid *Buffer, ILuint Size, ILuint Number);
25	ILuint ILAPIENTRY iReadLump(ILvoid *Buffer, ILuint Size, ILuint Number);	25	ILuint ILAPIENTRY iReadLump(ILvoid *Buffer, ILuint Size, ILuint Number);
26	ILuint ILAPIENTRY iSeekRFile(ILint Offset, ILuint Mode);	26	ILuint ILAPIENTRY iSeekRFile(ILint Offset, ILuint Mode);
27	ILuint ILAPIENTRY iSeekRLump(ILint Offset, ILuint Mode);	27	ILuint ILAPIENTRY iSeekRLump(ILint Offset, ILuint Mode);
28	ILuint ILAPIENTRY iSeekWFile(ILint Offset, ILuint Mode);	28	ILuint ILAPIENTRY iSeekWFile(ILint Offset, ILuint Mode);
29	ILuint ILAPIENTRY iSeekWLump(ILint Offset, ILuint Mode);	29	ILuint ILAPIENTRY iSeekWLump(ILint Offset, ILuint Mode);
30	ILuint ILAPIENTRY iTellRFile(ILvoid);	30	ILuint ILAPIENTRY iTellRFile(void);
31	ILuint ILAPIENTRY iTellRLump(ILvoid);	31	ILuint ILAPIENTRY iTellRLump(void);
32	ILuint ILAPIENTRY iTellWFile(ILvoid);	32	ILuint ILAPIENTRY iTellWFile(void);
33	ILuint ILAPIENTRY iTellWLump(ILvoid);	33	ILuint ILAPIENTRY iTellWLump(void);
34	ILint ILAPIENTRY iPutcFile(ILubyte Char);	34	ILint ILAPIENTRY iPutcFile(ILubyte Char);
35	ILint ILAPIENTRY iPutcLump(ILubyte Char);	35	ILint ILAPIENTRY iPutcLump(ILubyte Char);
36	ILint ILAPIENTRY iWriteFile(const ILvoid *Buffer, ILuint Size, ILuint Number);	36	ILint ILAPIENTRY iWriteFile(const ILvoid *Buffer, ILuint Size, ILuint Number);
Lines 340-352 ILvoid ipad(ILuint NumZeros) Link Here
340		340
341	// Next 12 functions are the default write functions	341	// Next 12 functions are the default write functions
342		342
343	ILboolean ILAPIENTRY iEofFile(ILvoid)	343	ILboolean ILAPIENTRY iEofFile(void)
344	{	344	{
345	return EofProc((FILE*)FileRead);	345	return EofProc((FILE*)FileRead);
346	}	346	}
347		347
348		348
349	ILboolean ILAPIENTRY iEofLump(ILvoid)	349	ILboolean ILAPIENTRY iEofLump(void)
350	{	350	{
351	if (ReadLumpSize)	351	if (ReadLumpSize)
352	return (ReadLumpPos >= ReadLumpSize);	352	return (ReadLumpPos >= ReadLumpSize);
Lines 354-360 ILboolean ILAPIENTRY iEofLump(ILvoid) Link Here
354	}	354	}
355		355
356		356
357	ILint ILAPIENTRY iGetcFile(ILvoid)	357	ILint ILAPIENTRY iGetcFile(void)
358	{	358	{
359	if (!UseCache) {	359	if (!UseCache) {
360	return GetcProc(FileRead);	360	return GetcProc(FileRead);
Lines 368-374 ILint ILAPIENTRY iGetcFile(ILvoid) Link Here
368	}	368	}
369		369
370		370
371	ILint ILAPIENTRY iGetcLump(ILvoid)	371	ILint ILAPIENTRY iGetcLump(void)
372	{	372	{
373	// If ReadLumpSize is 0, don't even check to see if we've gone past the bounds.	373	// If ReadLumpSize is 0, don't even check to see if we've gone past the bounds.
374	if (ReadLumpSize > 0) {	374	if (ReadLumpSize > 0) {
Lines 564-588 ILuint ILAPIENTRY iSeekRLump(ILint Offse Link Here
564	}	564	}
565		565
566		566
567	ILuint ILAPIENTRY iTellRFile(ILvoid)	567	ILuint ILAPIENTRY iTellRFile(void)
568	{	568	{
569	return TellRProc(FileRead);	569	return TellRProc(FileRead);
570	}	570	}
571		571
572		572
573	ILuint ILAPIENTRY iTellRLump(ILvoid)	573	ILuint ILAPIENTRY iTellRLump(void)
574	{	574	{
575	return ReadLumpPos;	575	return ReadLumpPos;
576	}	576	}
577		577
578		578
579	ILHANDLE ILAPIENTRY iGetFile(ILvoid)	579	ILHANDLE ILAPIENTRY iGetFile(void)
580	{	580	{
581	return FileRead;	581	return FileRead;
582	}	582	}
583		583
584		584
585	ILubyte* ILAPIENTRY iGetLump(ILvoid)	585	ILubyte* ILAPIENTRY iGetLump(void)
586	{	586	{
587	return ReadLump;	587	return ReadLump;
588	}	588	}
Lines 683-695 ILuint ILAPIENTRY iSeekWLump(ILint Offse Link Here
683	}	683	}
684		684
685		685
686	ILuint ILAPIENTRY iTellWFile(ILvoid)	686	ILuint ILAPIENTRY iTellWFile(void)
687	{	687	{
688	return TellWProc(FileWrite);	688	return TellWProc(FileWrite);
689	}	689	}
690		690
691		691
692	ILuint ILAPIENTRY iTellWLump(ILvoid)	692	ILuint ILAPIENTRY iTellWLump(void)
693	{	693	{
694	return WriteLumpPos;	694	return WriteLumpPos;
695	}	695	}

Lines 74-80 ILAPI ILvoid* ILAPIENTRY ivec_align_buff Link Here

(-)DevIL-1.6.7/include/IL/devil_internal_exports.h (-4 / +4 lines)
74	#endif	74	#endif
75		75
76	// Internal library functions in IL	76	// Internal library functions in IL
77	ILAPI ILimage* ILAPIENTRY ilGetCurImage(ILvoid);	77	ILAPI ILimage* ILAPIENTRY ilGetCurImage(void);
78	ILAPI ILvoid ILAPIENTRY ilSetCurImage(ILimage *Image);	78	ILAPI ILvoid ILAPIENTRY ilSetCurImage(ILimage *Image);
79	ILAPI ILvoid ILAPIENTRY ilSetError(ILenum Error);	79	ILAPI ILvoid ILAPIENTRY ilSetError(ILenum Error);
80	ILAPI ILvoid ILAPIENTRY ilSetPal(ILpal *Pal);	80	ILAPI ILvoid ILAPIENTRY ilSetPal(ILpal *Pal);
Lines 95-109 ILAPI ILvoid ILAPIENTRY ilReplaceCurImag Link Here
95	//	95	//
96	// Image functions	96	// Image functions
97	//	97	//
98	ILAPI ILvoid ILAPIENTRY iBindImageTemp (ILvoid);	98	ILAPI ILvoid ILAPIENTRY iBindImageTemp (void);
99	ILAPI ILboolean ILAPIENTRY ilClearImage_ (ILimage *Image);	99	ILAPI ILboolean ILAPIENTRY ilClearImage_ (ILimage *Image);
100	ILAPI ILvoid ILAPIENTRY ilCloseImage (ILimage *Image);	100	ILAPI ILvoid ILAPIENTRY ilCloseImage (ILimage *Image);
101	ILAPI ILvoid ILAPIENTRY ilClosePal (ILpal *Palette);	101	ILAPI ILvoid ILAPIENTRY ilClosePal (ILpal *Palette);
102	ILAPI ILpal* ILAPIENTRY iCopyPal (ILvoid);	102	ILAPI ILpal* ILAPIENTRY iCopyPal (void);
103	ILAPI ILboolean ILAPIENTRY ilCopyImageAttr (ILimage Dest, ILimage Src);	103	ILAPI ILboolean ILAPIENTRY ilCopyImageAttr (ILimage Dest, ILimage Src);
104	ILAPI ILimage* ILAPIENTRY ilCopyImage_ (ILimage *Src);	104	ILAPI ILimage* ILAPIENTRY ilCopyImage_ (ILimage *Src);
105	ILAPI ILvoid ILAPIENTRY ilGetClear (ILvoid *Colours, ILenum Format, ILenum Type);	105	ILAPI ILvoid ILAPIENTRY ilGetClear (ILvoid *Colours, ILenum Format, ILenum Type);
106	ILAPI ILuint ILAPIENTRY ilGetCurName (ILvoid);	106	ILAPI ILuint ILAPIENTRY ilGetCurName (void);
107	ILAPI ILboolean ILAPIENTRY ilIsValidPal (ILpal *Palette);	107	ILAPI ILboolean ILAPIENTRY ilIsValidPal (ILpal *Palette);
108	ILAPI ILimage* ILAPIENTRY ilNewImage (ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILubyte Bpc);	108	ILAPI ILimage* ILAPIENTRY ilNewImage (ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILubyte Bpc);
109	ILAPI ILimage* ILAPIENTRY ilNewImageFull (ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, ILvoid *Data);	109	ILAPI ILimage* ILAPIENTRY ilNewImageFull (ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, ILvoid *Data);

Lines 494-508 ILAPI ILboolean ILAPIENTRY ilApplyProfi Link Here

(-)DevIL-1.6.7/include/IL/il.h (-13 / +13 lines)
494	ILAPI ILvoid ILAPIENTRY ilBindImage(ILuint Image);	494	ILAPI ILvoid ILAPIENTRY ilBindImage(ILuint Image);
495	ILAPI ILboolean ILAPIENTRY ilBlit(ILuint Source, ILint DestX, ILint DestY, ILint DestZ, ILuint SrcX, ILuint SrcY, ILuint SrcZ, ILuint Width, ILuint Height, ILuint Depth);	495	ILAPI ILboolean ILAPIENTRY ilBlit(ILuint Source, ILint DestX, ILint DestY, ILint DestZ, ILuint SrcX, ILuint SrcY, ILuint SrcZ, ILuint Width, ILuint Height, ILuint Depth);
496	ILAPI ILvoid ILAPIENTRY ilClearColour(ILclampf Red, ILclampf Green, ILclampf Blue, ILclampf Alpha);	496	ILAPI ILvoid ILAPIENTRY ilClearColour(ILclampf Red, ILclampf Green, ILclampf Blue, ILclampf Alpha);
497	ILAPI ILboolean ILAPIENTRY ilClearImage(ILvoid);	497	ILAPI ILboolean ILAPIENTRY ilClearImage(void);
498	ILAPI ILuint ILAPIENTRY ilCloneCurImage(ILvoid);	498	ILAPI ILuint ILAPIENTRY ilCloneCurImage(void);
499	ILAPI ILboolean ILAPIENTRY ilCompressFunc(ILenum Mode);	499	ILAPI ILboolean ILAPIENTRY ilCompressFunc(ILenum Mode);
500	ILAPI ILboolean ILAPIENTRY ilConvertImage(ILenum DestFormat, ILenum DestType);	500	ILAPI ILboolean ILAPIENTRY ilConvertImage(ILenum DestFormat, ILenum DestType);
501	ILAPI ILboolean ILAPIENTRY ilConvertPal(ILenum DestFormat);	501	ILAPI ILboolean ILAPIENTRY ilConvertPal(ILenum DestFormat);
502	ILAPI ILboolean ILAPIENTRY ilCopyImage(ILuint Src);	502	ILAPI ILboolean ILAPIENTRY ilCopyImage(ILuint Src);
503	ILAPI ILuint ILAPIENTRY ilCopyPixels(ILuint XOff, ILuint YOff, ILuint ZOff, ILuint Width, ILuint Height, ILuint Depth, ILenum Format, ILenum Type, ILvoid *Data);	503	ILAPI ILuint ILAPIENTRY ilCopyPixels(ILuint XOff, ILuint YOff, ILuint ZOff, ILuint Width, ILuint Height, ILuint Depth, ILenum Format, ILenum Type, ILvoid *Data);
504	ILAPI ILuint ILAPIENTRY ilCreateSubImage(ILenum Type, ILuint Num);	504	ILAPI ILuint ILAPIENTRY ilCreateSubImage(ILenum Type, ILuint Num);
505	ILAPI ILboolean ILAPIENTRY ilDefaultImage(ILvoid);	505	ILAPI ILboolean ILAPIENTRY ilDefaultImage(void);
506	ILAPI ILvoid ILAPIENTRY ilDeleteImages(ILsizei Num, const ILuint *Images);	506	ILAPI ILvoid ILAPIENTRY ilDeleteImages(ILsizei Num, const ILuint *Images);
507	ILAPI ILboolean ILAPIENTRY ilDisable(ILenum Mode);	507	ILAPI ILboolean ILAPIENTRY ilDisable(ILenum Mode);
508	ILAPI ILboolean ILAPIENTRY ilEnable(ILenum Mode);	508	ILAPI ILboolean ILAPIENTRY ilEnable(ILenum Mode);
Lines 513-528 ILAPI ILvoid ILAPIENTRY ilMod Link Here
513	ILAPI ILvoid ILAPIENTRY ilSetAlpha( ILdouble AlphaValue );	513	ILAPI ILvoid ILAPIENTRY ilSetAlpha( ILdouble AlphaValue );
514	ILAPI ILboolean ILAPIENTRY ilGetBoolean(ILenum Mode);	514	ILAPI ILboolean ILAPIENTRY ilGetBoolean(ILenum Mode);
515	ILAPI ILvoid ILAPIENTRY ilGetBooleanv(ILenum Mode, ILboolean *Param);	515	ILAPI ILvoid ILAPIENTRY ilGetBooleanv(ILenum Mode, ILboolean *Param);
516	ILAPI ILubyte* ILAPIENTRY ilGetData(ILvoid);	516	ILAPI ILubyte* ILAPIENTRY ilGetData(void);
517	ILAPI ILuint ILAPIENTRY ilGetDXTCData(ILvoid *Buffer, ILuint BufferSize, ILenum DXTCFormat);	517	ILAPI ILuint ILAPIENTRY ilGetDXTCData(ILvoid *Buffer, ILuint BufferSize, ILenum DXTCFormat);
518	ILAPI ILenum ILAPIENTRY ilGetError(ILvoid);	518	ILAPI ILenum ILAPIENTRY ilGetError(void);
519	ILAPI ILint ILAPIENTRY ilGetInteger(ILenum Mode);	519	ILAPI ILint ILAPIENTRY ilGetInteger(ILenum Mode);
520	ILAPI ILvoid ILAPIENTRY ilGetIntegerv(ILenum Mode, ILint *Param);	520	ILAPI ILvoid ILAPIENTRY ilGetIntegerv(ILenum Mode, ILint *Param);
521	ILAPI ILuint ILAPIENTRY ilGetLumpPos(ILvoid);	521	ILAPI ILuint ILAPIENTRY ilGetLumpPos(void);
522	ILAPI ILubyte* ILAPIENTRY ilGetPalette(ILvoid);	522	ILAPI ILubyte* ILAPIENTRY ilGetPalette(void);
523	ILAPI const ILstring ILAPIENTRY ilGetString(ILenum StringName);	523	ILAPI const ILstring ILAPIENTRY ilGetString(ILenum StringName);
524	ILAPI ILvoid ILAPIENTRY ilHint(ILenum Target, ILenum Mode);	524	ILAPI ILvoid ILAPIENTRY ilHint(ILenum Target, ILenum Mode);
525	ILAPI ILvoid ILAPIENTRY ilInit(ILvoid);	525	ILAPI ILvoid ILAPIENTRY ilInit(void);
526	ILAPI ILboolean ILAPIENTRY ilIsDisabled(ILenum Mode);	526	ILAPI ILboolean ILAPIENTRY ilIsDisabled(ILenum Mode);
527	ILAPI ILboolean ILAPIENTRY ilIsEnabled(ILenum Mode);	527	ILAPI ILboolean ILAPIENTRY ilIsEnabled(ILenum Mode);
528	ILAPI ILboolean ILAPIENTRY ilIsImage(ILuint Image);	528	ILAPI ILboolean ILAPIENTRY ilIsImage(ILuint Image);
Lines 537-543 ILAPI ILboolean ILAPIENTRY ilLoadL(ILen Link Here
537	ILAPI ILboolean ILAPIENTRY ilLoadPal(const ILstring FileName);	537	ILAPI ILboolean ILAPIENTRY ilLoadPal(const ILstring FileName);
538	ILAPI ILboolean ILAPIENTRY ilOriginFunc(ILenum Mode);	538	ILAPI ILboolean ILAPIENTRY ilOriginFunc(ILenum Mode);
539	ILAPI ILboolean ILAPIENTRY ilOverlayImage(ILuint Source, ILint XCoord, ILint YCoord, ILint ZCoord);	539	ILAPI ILboolean ILAPIENTRY ilOverlayImage(ILuint Source, ILint XCoord, ILint YCoord, ILint ZCoord);
540	ILAPI ILvoid ILAPIENTRY ilPopAttrib(ILvoid);	540	ILAPI ILvoid ILAPIENTRY ilPopAttrib(void);
541	ILAPI ILvoid ILAPIENTRY ilPushAttrib(ILuint Bits);	541	ILAPI ILvoid ILAPIENTRY ilPushAttrib(ILuint Bits);
542	ILAPI ILvoid ILAPIENTRY ilRegisterFormat(ILenum Format);	542	ILAPI ILvoid ILAPIENTRY ilRegisterFormat(ILenum Format);
543	ILAPI ILboolean ILAPIENTRY ilRegisterLoad(const ILstring Ext, IL_LOADPROC Load);	543	ILAPI ILboolean ILAPIENTRY ilRegisterLoad(const ILstring Ext, IL_LOADPROC Load);
Lines 549-557 ILAPI ILboolean ILAPIENTRY ilRegisterSa Link Here
549	ILAPI ILvoid ILAPIENTRY ilRegisterType(ILenum Type);	549	ILAPI ILvoid ILAPIENTRY ilRegisterType(ILenum Type);
550	ILAPI ILboolean ILAPIENTRY ilRemoveLoad(const ILstring Ext);	550	ILAPI ILboolean ILAPIENTRY ilRemoveLoad(const ILstring Ext);
551	ILAPI ILboolean ILAPIENTRY ilRemoveSave(const ILstring Ext);	551	ILAPI ILboolean ILAPIENTRY ilRemoveSave(const ILstring Ext);
552	ILAPI ILvoid ILAPIENTRY ilResetMemory(ILvoid);	552	ILAPI ILvoid ILAPIENTRY ilResetMemory(void);
553	ILAPI ILvoid ILAPIENTRY ilResetRead(ILvoid);	553	ILAPI ILvoid ILAPIENTRY ilResetRead(void);
554	ILAPI ILvoid ILAPIENTRY ilResetWrite(ILvoid);	554	ILAPI ILvoid ILAPIENTRY ilResetWrite(void);
555	ILAPI ILboolean ILAPIENTRY ilSave(ILenum Type, const ILstring FileName);	555	ILAPI ILboolean ILAPIENTRY ilSave(ILenum Type, const ILstring FileName);
556	ILAPI ILuint ILAPIENTRY ilSaveF(ILenum Type, ILHANDLE File);	556	ILAPI ILuint ILAPIENTRY ilSaveF(ILenum Type, ILHANDLE File);
557	ILAPI ILboolean ILAPIENTRY ilSaveImage(const ILstring FileName);	557	ILAPI ILboolean ILAPIENTRY ilSaveImage(const ILstring FileName);
Lines 565-571 ILAPI ILvoid ILAPIENTRY ilSetPixels(ILi Link Here
565	ILAPI ILvoid ILAPIENTRY ilSetRead(fOpenRProc, fCloseRProc, fEofProc, fGetcProc, fReadProc, fSeekRProc, fTellRProc);	565	ILAPI ILvoid ILAPIENTRY ilSetRead(fOpenRProc, fCloseRProc, fEofProc, fGetcProc, fReadProc, fSeekRProc, fTellRProc);
566	ILAPI ILvoid ILAPIENTRY ilSetString(ILenum Mode, const char *String);	566	ILAPI ILvoid ILAPIENTRY ilSetString(ILenum Mode, const char *String);
567	ILAPI ILvoid ILAPIENTRY ilSetWrite(fOpenWProc, fCloseWProc, fPutcProc, fSeekWProc, fTellWProc, fWriteProc);	567	ILAPI ILvoid ILAPIENTRY ilSetWrite(fOpenWProc, fCloseWProc, fPutcProc, fSeekWProc, fTellWProc, fWriteProc);
568	ILAPI ILvoid ILAPIENTRY ilShutDown(ILvoid);	568	ILAPI ILvoid ILAPIENTRY ilShutDown(void);
569	ILAPI ILboolean ILAPIENTRY ilTexImage(ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, ILvoid *Data);	569	ILAPI ILboolean ILAPIENTRY ilTexImage(ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILenum Format, ILenum Type, ILvoid *Data);
570	ILAPI ILboolean ILAPIENTRY ilTypeFunc(ILenum Mode);	570	ILAPI ILboolean ILAPIENTRY ilTypeFunc(ILenum Mode);
571		571

Lines 132-167 typedef struct ILpointi Link Here

(-)DevIL-1.6.7/include/IL/ilu.h (-15 / +15 lines)
132		132
133		133
134	// ImageLib Utility Functions	134	// ImageLib Utility Functions
135	ILAPI ILboolean ILAPIENTRY iluAlienify(ILvoid);	135	ILAPI ILboolean ILAPIENTRY iluAlienify(void);
136	ILAPI ILboolean ILAPIENTRY iluBlurAvg(ILuint Iter);	136	ILAPI ILboolean ILAPIENTRY iluBlurAvg(ILuint Iter);
137	ILAPI ILboolean ILAPIENTRY iluBlurGaussian(ILuint Iter);	137	ILAPI ILboolean ILAPIENTRY iluBlurGaussian(ILuint Iter);
138	ILAPI ILboolean ILAPIENTRY iluBuildMipmaps(ILvoid);	138	ILAPI ILboolean ILAPIENTRY iluBuildMipmaps(void);
139	ILAPI ILuint ILAPIENTRY iluColoursUsed(ILvoid);	139	ILAPI ILuint ILAPIENTRY iluColoursUsed(void);
140	ILAPI ILboolean ILAPIENTRY iluCompareImage(ILuint Comp);	140	ILAPI ILboolean ILAPIENTRY iluCompareImage(ILuint Comp);
141	ILAPI ILboolean ILAPIENTRY iluContrast(ILfloat Contrast);	141	ILAPI ILboolean ILAPIENTRY iluContrast(ILfloat Contrast);
142	ILAPI ILboolean ILAPIENTRY iluCrop(ILuint XOff, ILuint YOff, ILuint ZOff, ILuint Width, ILuint Height, ILuint Depth);	142	ILAPI ILboolean ILAPIENTRY iluCrop(ILuint XOff, ILuint YOff, ILuint ZOff, ILuint Width, ILuint Height, ILuint Depth);
143	ILAPI ILvoid ILAPIENTRY iluDeleteImage(ILuint Id);	143	ILAPI ILvoid ILAPIENTRY iluDeleteImage(ILuint Id);
144	ILAPI ILboolean ILAPIENTRY iluEdgeDetectE(ILvoid);	144	ILAPI ILboolean ILAPIENTRY iluEdgeDetectE(void);
145	ILAPI ILboolean ILAPIENTRY iluEdgeDetectP(ILvoid);	145	ILAPI ILboolean ILAPIENTRY iluEdgeDetectP(void);
146	ILAPI ILboolean ILAPIENTRY iluEdgeDetectS(ILvoid);	146	ILAPI ILboolean ILAPIENTRY iluEdgeDetectS(void);
147	ILAPI ILboolean ILAPIENTRY iluEmboss(ILvoid);	147	ILAPI ILboolean ILAPIENTRY iluEmboss(void);
148	ILAPI ILboolean ILAPIENTRY iluEnlargeCanvas(ILuint Width, ILuint Height, ILuint Depth);	148	ILAPI ILboolean ILAPIENTRY iluEnlargeCanvas(ILuint Width, ILuint Height, ILuint Depth);
149	ILAPI ILboolean ILAPIENTRY iluEnlargeImage(ILfloat XDim, ILfloat YDim, ILfloat ZDim);	149	ILAPI ILboolean ILAPIENTRY iluEnlargeImage(ILfloat XDim, ILfloat YDim, ILfloat ZDim);
150	ILAPI ILboolean ILAPIENTRY iluEqualize(ILvoid);	150	ILAPI ILboolean ILAPIENTRY iluEqualize(void);
151	ILAPI const ILstring ILAPIENTRY iluErrorString(ILenum Error);	151	ILAPI const ILstring ILAPIENTRY iluErrorString(ILenum Error);
152	ILAPI ILboolean ILAPIENTRY iluFlipImage(ILvoid);	152	ILAPI ILboolean ILAPIENTRY iluFlipImage(void);
153	ILAPI ILboolean ILAPIENTRY iluGammaCorrect(ILfloat Gamma);	153	ILAPI ILboolean ILAPIENTRY iluGammaCorrect(ILfloat Gamma);
154	ILAPI ILuint ILAPIENTRY iluGenImage(ILvoid);	154	ILAPI ILuint ILAPIENTRY iluGenImage(void);
155	ILAPI ILvoid ILAPIENTRY iluGetImageInfo(ILinfo *Info);	155	ILAPI ILvoid ILAPIENTRY iluGetImageInfo(ILinfo *Info);
156	ILAPI ILint ILAPIENTRY iluGetInteger(ILenum Mode);	156	ILAPI ILint ILAPIENTRY iluGetInteger(ILenum Mode);
157	ILAPI ILvoid ILAPIENTRY iluGetIntegerv(ILenum Mode, ILint *Param);	157	ILAPI ILvoid ILAPIENTRY iluGetIntegerv(ILenum Mode, ILint *Param);
158	ILAPI const ILstring ILAPIENTRY iluGetString(ILenum StringName);	158	ILAPI const ILstring ILAPIENTRY iluGetString(ILenum StringName);
159	ILAPI ILvoid ILAPIENTRY iluImageParameter(ILenum PName, ILenum Param);	159	ILAPI ILvoid ILAPIENTRY iluImageParameter(ILenum PName, ILenum Param);
160	ILAPI ILvoid ILAPIENTRY iluInit(ILvoid);	160	ILAPI ILvoid ILAPIENTRY iluInit(void);
161	ILAPI ILboolean ILAPIENTRY iluInvertAlpha(ILvoid);	161	ILAPI ILboolean ILAPIENTRY iluInvertAlpha(void);
162	ILAPI ILuint ILAPIENTRY iluLoadImage(const ILstring FileName);	162	ILAPI ILuint ILAPIENTRY iluLoadImage(const ILstring FileName);
163	ILAPI ILboolean ILAPIENTRY iluMirror(ILvoid);	163	ILAPI ILboolean ILAPIENTRY iluMirror(void);
164	ILAPI ILboolean ILAPIENTRY iluNegative(ILvoid);	164	ILAPI ILboolean ILAPIENTRY iluNegative(void);
165	ILAPI ILboolean ILAPIENTRY iluNoisify(ILclampf Tolerance);	165	ILAPI ILboolean ILAPIENTRY iluNoisify(ILclampf Tolerance);
166	ILAPI ILboolean ILAPIENTRY iluPixelize(ILuint PixSize);	166	ILAPI ILboolean ILAPIENTRY iluPixelize(ILuint PixSize);
167	ILAPI ILvoid ILAPIENTRY iluRegionfv(ILpointf *Points, ILuint n);	167	ILAPI ILvoid ILAPIENTRY iluRegionfv(ILpointf *Points, ILuint n);
Lines 174-180 ILAPI ILboolean ILAPIENTRY iluSaturate Link Here
174	ILAPI ILboolean ILAPIENTRY iluScale(ILuint Width, ILuint Height, ILuint Depth);	174	ILAPI ILboolean ILAPIENTRY iluScale(ILuint Width, ILuint Height, ILuint Depth);
175	ILAPI ILboolean ILAPIENTRY iluScaleColours(ILfloat r, ILfloat g, ILfloat b);	175	ILAPI ILboolean ILAPIENTRY iluScaleColours(ILfloat r, ILfloat g, ILfloat b);
176	ILAPI ILboolean ILAPIENTRY iluSharpen(ILfloat Factor, ILuint Iter);	176	ILAPI ILboolean ILAPIENTRY iluSharpen(ILfloat Factor, ILuint Iter);
177	ILAPI ILboolean ILAPIENTRY iluSwapColours(ILvoid);	177	ILAPI ILboolean ILAPIENTRY iluSwapColours(void);
178	ILAPI ILboolean ILAPIENTRY iluWave(ILfloat Angle);	178	ILAPI ILboolean ILAPIENTRY iluWave(ILfloat Angle);
179		179
180	#define iluColorsUsed iluColoursUsed	180	#define iluColorsUsed iluColoursUsed

Lines 103-112 ILAPI ILvoid ILAPIENTRY ilutGetBooleanv Link Here

(-)DevIL-1.6.7/include/IL/ilut.h (-11 / +11 lines)
103	ILAPI ILint ILAPIENTRY ilutGetInteger(ILenum Mode);	103	ILAPI ILint ILAPIENTRY ilutGetInteger(ILenum Mode);
104	ILAPI ILvoid ILAPIENTRY ilutGetIntegerv(ILenum Mode, ILint *Param);	104	ILAPI ILvoid ILAPIENTRY ilutGetIntegerv(ILenum Mode, ILint *Param);
105	ILAPI const ILstring ILAPIENTRY ilutGetString(ILenum StringName);	105	ILAPI const ILstring ILAPIENTRY ilutGetString(ILenum StringName);
106	ILAPI ILvoid ILAPIENTRY ilutInit(ILvoid);	106	ILAPI ILvoid ILAPIENTRY ilutInit(void);
107	ILAPI ILboolean ILAPIENTRY ilutIsDisabled(ILenum Mode);	107	ILAPI ILboolean ILAPIENTRY ilutIsDisabled(ILenum Mode);
108	ILAPI ILboolean ILAPIENTRY ilutIsEnabled(ILenum Mode);	108	ILAPI ILboolean ILAPIENTRY ilutIsEnabled(ILenum Mode);
109	ILAPI ILvoid ILAPIENTRY ilutPopAttrib(ILvoid);	109	ILAPI ILvoid ILAPIENTRY ilutPopAttrib(void);
110	ILAPI ILvoid ILAPIENTRY ilutPushAttrib(ILuint Bits);	110	ILAPI ILvoid ILAPIENTRY ilutPushAttrib(ILuint Bits);
111	ILAPI ILvoid ILAPIENTRY ilutSetInteger(ILenum Mode, ILint Param);	111	ILAPI ILvoid ILAPIENTRY ilutSetInteger(ILenum Mode, ILint Param);
112		112
Lines 171-181 ILAPI ILboolean ILAPIENTRY ilutRenderer( Link Here
171	#endif//__APPLE__	171	#endif//__APPLE__
172		172
173	ILAPI GLuint ILAPIENTRY ilutGLBindTexImage();	173	ILAPI GLuint ILAPIENTRY ilutGLBindTexImage();
174	ILAPI GLuint ILAPIENTRY ilutGLBindMipmaps(ILvoid);	174	ILAPI GLuint ILAPIENTRY ilutGLBindMipmaps(void);
175	ILAPI ILboolean ILAPIENTRY ilutGLBuildMipmaps(ILvoid);	175	ILAPI ILboolean ILAPIENTRY ilutGLBuildMipmaps(void);
176	ILAPI GLuint ILAPIENTRY ilutGLLoadImage(const ILstring FileName);	176	ILAPI GLuint ILAPIENTRY ilutGLLoadImage(const ILstring FileName);
177	ILAPI ILboolean ILAPIENTRY ilutGLScreen(ILvoid);	177	ILAPI ILboolean ILAPIENTRY ilutGLScreen(void);
178	ILAPI ILboolean ILAPIENTRY ilutGLScreenie(ILvoid);	178	ILAPI ILboolean ILAPIENTRY ilutGLScreenie(void);
179	ILAPI ILboolean ILAPIENTRY ilutGLSaveImage(const ILstring FileName, GLuint TexID);	179	ILAPI ILboolean ILAPIENTRY ilutGLSaveImage(const ILstring FileName, GLuint TexID);
180	ILAPI ILboolean ILAPIENTRY ilutGLSetTex(GLuint TexID);	180	ILAPI ILboolean ILAPIENTRY ilutGLSetTex(GLuint TexID);
181	ILAPI ILboolean ILAPIENTRY ilutGLTexImage(GLuint Level);	181	ILAPI ILboolean ILAPIENTRY ilutGLTexImage(GLuint Level);
Lines 202-208 ILAPI ILboolean ILAPIENTRY ilutRenderer( Link Here
202		202
203	// ImageLib Utility Toolkit's BeOS Functions	203	// ImageLib Utility Toolkit's BeOS Functions
204	#ifdef ILUT_USE_BEOS	204	#ifdef ILUT_USE_BEOS
205	ILAPI BBitmap ILAPIENTRY ilutConvertToBBitmap(ILvoid);	205	ILAPI BBitmap ILAPIENTRY ilutConvertToBBitmap(void);
206	#endif//ILUT_USE_BEOS	206	#endif//ILUT_USE_BEOS
207		207
208		208
Lines 216-228 ILAPI ILboolean ILAPIENTRY ilutRenderer( Link Here
216	ILAPI HBITMAP ILAPIENTRY ilutConvertSliceToHBitmap(HDC hDC, ILuint slice);	216	ILAPI HBITMAP ILAPIENTRY ilutConvertSliceToHBitmap(HDC hDC, ILuint slice);
217	ILAPI ILvoid ILAPIENTRY ilutFreePaddedData(ILubyte *Data);	217	ILAPI ILvoid ILAPIENTRY ilutFreePaddedData(ILubyte *Data);
218	ILAPI ILvoid ILAPIENTRY ilutGetBmpInfo(BITMAPINFO *Info);	218	ILAPI ILvoid ILAPIENTRY ilutGetBmpInfo(BITMAPINFO *Info);
219	ILAPI HPALETTE ILAPIENTRY ilutGetHPal(ILvoid);	219	ILAPI HPALETTE ILAPIENTRY ilutGetHPal(void);
220	ILAPI ILubyte* ILAPIENTRY ilutGetPaddedData(ILvoid);	220	ILAPI ILubyte* ILAPIENTRY ilutGetPaddedData(void);
221	ILAPI ILboolean ILAPIENTRY ilutGetWinClipboard(ILvoid);	221	ILAPI ILboolean ILAPIENTRY ilutGetWinClipboard(void);
222	ILAPI ILboolean ILAPIENTRY ilutLoadResource(HINSTANCE hInst, ILint ID, const ILstring ResourceType, ILenum Type);	222	ILAPI ILboolean ILAPIENTRY ilutLoadResource(HINSTANCE hInst, ILint ID, const ILstring ResourceType, ILenum Type);
223	ILAPI ILboolean ILAPIENTRY ilutSetHBitmap(HBITMAP Bitmap);	223	ILAPI ILboolean ILAPIENTRY ilutSetHBitmap(HBITMAP Bitmap);
224	ILAPI ILboolean ILAPIENTRY ilutSetHPal(HPALETTE Pal);	224	ILAPI ILboolean ILAPIENTRY ilutSetHPal(HPALETTE Pal);
225	ILAPI ILboolean ILAPIENTRY ilutSetWinClipboard(ILvoid);	225	ILAPI ILboolean ILAPIENTRY ilutSetWinClipboard(void);
226	ILAPI HBITMAP ILAPIENTRY ilutWinLoadImage(const ILstring FileName, HDC hDC);	226	ILAPI HBITMAP ILAPIENTRY ilutWinLoadImage(const ILstring FileName, HDC hDC);
227	ILAPI ILboolean ILAPIENTRY ilutWinLoadUrl(const ILstring Url);	227	ILAPI ILboolean ILAPIENTRY ilutWinLoadUrl(const ILstring Url);
228	ILAPI ILboolean ILAPIENTRY ilutWinPrint(ILuint XPos, ILuint YPos, ILuint Width, ILuint Height, HDC hDC);	228	ILAPI ILboolean ILAPIENTRY ilutWinPrint(ILuint XPos, ILuint YPos, ILuint Width, ILuint Height, HDC hDC);

Lines 29-72 public: Link Here

(-)DevIL-1.6.7/include/IL/il_wrap.h (-30 / +30 lines)
29	ILboolean ActiveImage(ILuint);	29	ILboolean ActiveImage(ILuint);
30	ILboolean ActiveLayer(ILuint);	30	ILboolean ActiveLayer(ILuint);
31	ILboolean ActiveMipmap(ILuint);	31	ILboolean ActiveMipmap(ILuint);
32	ILboolean Clear(ILvoid);	32	ILboolean Clear(void);
33	ILvoid ClearColour(ILubyte, ILubyte, ILubyte, ILubyte);	33	ILvoid ClearColour(ILubyte, ILubyte, ILubyte, ILubyte);
34	ILboolean Convert(ILenum);	34	ILboolean Convert(ILenum);
35	ILboolean Copy(ILuint);	35	ILboolean Copy(ILuint);
36	ILboolean Default(ILvoid);	36	ILboolean Default(void);
37	ILboolean Flip(ILvoid);	37	ILboolean Flip(void);
38	ILboolean SwapColours(ILvoid);	38	ILboolean SwapColours(void);
39	ILboolean Resize(ILuint, ILuint, ILuint);	39	ILboolean Resize(ILuint, ILuint, ILuint);
40	ILboolean TexImage(ILuint, ILuint, ILuint, ILubyte, ILenum, ILenum, ILvoid*);	40	ILboolean TexImage(ILuint, ILuint, ILuint, ILubyte, ILenum, ILenum, ILvoid*);
41		41
42		42
43	// Image handling	43	// Image handling
44	ILvoid Bind(ILvoid) const;	44	ILvoid Bind(void) const;
45	ILvoid Bind(ILuint);	45	ILvoid Bind(ILuint);
46	ILvoid Close(ILvoid) { this->Delete(); }	46	ILvoid Close(void) { this->Delete(); }
47	ILvoid Delete(ILvoid);	47	ILvoid Delete(void);
48	ILvoid iGenBind();	48	ILvoid iGenBind();
49		49
50		50
51	// Image characteristics	51	// Image characteristics
52	ILuint Width(ILvoid);	52	ILuint Width(void);
53	ILuint Height(ILvoid);	53	ILuint Height(void);
54	ILuint Depth(ILvoid);	54	ILuint Depth(void);
55	ILubyte Bpp(ILvoid);	55	ILubyte Bpp(void);
56	ILubyte Bitpp(ILvoid);	56	ILubyte Bitpp(void);
57	ILenum PaletteType(ILvoid);	57	ILenum PaletteType(void);
58	ILenum Format(ILvoid);	58	ILenum Format(void);
59	ILenum Type(ILvoid);	59	ILenum Type(void);
60	ILuint NumImages(ILvoid);	60	ILuint NumImages(void);
61	ILuint NumMipmaps(ILvoid);	61	ILuint NumMipmaps(void);
62	ILuint GetId(ILvoid) const;	62	ILuint GetId(void) const;
63	ILenum GetOrigin(ILvoid);	63	ILenum GetOrigin(void);
64	ILubyte *GetData(ILvoid);	64	ILubyte *GetData(void);
65	ILubyte *GetPalette(ILvoid);	65	ILubyte *GetPalette(void);
66		66
67		67
68	// Rendering	68	// Rendering
69	ILuint BindImage(ILvoid);	69	ILuint BindImage(void);
70	ILuint BindImage(ILenum);	70	ILuint BindImage(ILenum);
71		71
72		72
Lines 111-122 public: Link Here
111	class ilOgl	111	class ilOgl
112	{	112	{
113	public:	113	public:
114	static ILvoid Init(ILvoid);	114	static ILvoid Init(void);
115	static GLuint BindTex(ilImage &);	115	static GLuint BindTex(ilImage &);
116	static ILboolean Upload(ilImage &, ILuint);	116	static ILboolean Upload(ilImage &, ILuint);
117	static GLuint Mipmap(ilImage &);	117	static GLuint Mipmap(ilImage &);
118	static ILboolean Screen(ILvoid);	118	static ILboolean Screen(void);
119	static ILboolean Screenie(ILvoid);	119	static ILboolean Screenie(void);
120	};	120	};
121	#endif//ILUT_USE_OPENGL	121	#endif//ILUT_USE_OPENGL
122		122
Lines 125-131 public: Link Here
125	class ilAlleg	125	class ilAlleg
126	{	126	{
127	public:	127	public:
128	static ILvoid Init(ILvoid);	128	static ILvoid Init(void);
129	static BITMAP *Convert(ilImage &);	129	static BITMAP *Convert(ilImage &);
130	};	130	};
131	#endif//ILUT_USE_ALLEGRO	131	#endif//ILUT_USE_ALLEGRO
Lines 135-141 public: Link Here
135	class ilWin32	135	class ilWin32
136	{	136	{
137	public:	137	public:
138	static ILvoid Init(ILvoid);	138	static ILvoid Init(void);
139	static HBITMAP Convert(ilImage &);	139	static HBITMAP Convert(ilImage &);
140	static ILboolean GetClipboard(ilImage &);	140	static ILboolean GetClipboard(ilImage &);
141	static ILvoid GetInfo(ilImage &, BITMAPINFO *Info);	141	static ILvoid GetInfo(ilImage &, BITMAPINFO *Info);
Lines 175-181 public: Link Here
175	static ILboolean IsDisabled(ILenum);	175	static ILboolean IsDisabled(ILenum);
176	static ILboolean IsEnabled(ILenum);	176	static ILboolean IsEnabled(ILenum);
177	static ILboolean Origin(ILenum);	177	static ILboolean Origin(ILenum);
178	static ILvoid Pop(ILvoid);	178	static ILvoid Pop(void);
179	static ILvoid Push(ILuint);	179	static ILvoid Push(ILuint);
180		180
181		181
Lines 191-198 class ilError Link Here
191	public:	191	public:
192	static ILvoid Check(ILvoid (Callback)(const char));	192	static ILvoid Check(ILvoid (Callback)(const char));
193	static ILvoid Check(ILvoid (*Callback)(ILenum));	193	static ILvoid Check(ILvoid (*Callback)(ILenum));
194	static ILenum Get(ILvoid);	194	static ILenum Get(void);
195	static const char *String(ILvoid);	195	static const char *String(void);
196	static const char *String(ILenum);	196	static const char *String(ILenum);
197		197
198	protected:	198	protected:

Lines 65-82 ILvoid _SwapDouble(ILdouble *d); Link Here

(-)DevIL-1.6.7/src-IL/include/il_endian.h (-12 / +12 lines)
65	// ((f>>8) & 0xff000000) \| ((f<<8) & 0xff00000000) \| ((f<<24) & 0xff0000000000) \| ((f<<40) & 0xff000000000000) \| (f<<56))	65	// ((f>>8) & 0xff000000) \| ((f<<8) & 0xff00000000) \| ((f<<24) & 0xff0000000000) \| ((f<<40) & 0xff000000000000) \| (f<<56))
66		66
67		67
68	ILushort GetLittleUShort(ILvoid);	68	ILushort GetLittleUShort(void);
69	ILshort GetLittleShort(ILvoid);	69	ILshort GetLittleShort(void);
70	ILuint GetLittleUInt(ILvoid);	70	ILuint GetLittleUInt(void);
71	ILint GetLittleInt(ILvoid);	71	ILint GetLittleInt(void);
72	ILfloat GetLittleFloat(ILvoid);	72	ILfloat GetLittleFloat(void);
73	ILdouble GetLittleDouble(ILvoid);	73	ILdouble GetLittleDouble(void);
74	ILushort GetBigUShort(ILvoid);	74	ILushort GetBigUShort(void);
75	ILshort GetBigShort(ILvoid);	75	ILshort GetBigShort(void);
76	ILuint GetBigUInt(ILvoid);	76	ILuint GetBigUInt(void);
77	ILint GetBigInt(ILvoid);	77	ILint GetBigInt(void);
78	ILfloat GetBigFloat(ILvoid);	78	ILfloat GetBigFloat(void);
79	ILdouble GetBigDouble(ILvoid);	79	ILdouble GetBigDouble(void);
80		80
81	ILubyte SaveLittleUShort(ILushort _s);	81	ILubyte SaveLittleUShort(ILushort _s);
82	ILubyte SaveLittleShort(ILshort _s);	82	ILubyte SaveLittleShort(ILshort _s);

Lines 21-28 Link Here

(-)DevIL-1.6.7/src-IL/include/il_files.h (-9 / +9 lines)
21	#include <IL/il.h>	21	#include <IL/il.h>
22		22
23		23
24	__FILES_EXTERN ILvoid ILAPIENTRY iPreserveReadFuncs(ILvoid);	24	__FILES_EXTERN ILvoid ILAPIENTRY iPreserveReadFuncs(void);
25	__FILES_EXTERN ILvoid ILAPIENTRY iRestoreReadFuncs(ILvoid);	25	__FILES_EXTERN ILvoid ILAPIENTRY iRestoreReadFuncs(void);
26		26
27	__FILES_EXTERN fEofProc EofProc;	27	__FILES_EXTERN fEofProc EofProc;
28	__FILES_EXTERN fGetcProc GetcProc;	28	__FILES_EXTERN fGetcProc GetcProc;
Lines 47-59 __FILES_EXTERN ILint ILAPIENTRY iDefaul Link Here
47		47
48	__FILES_EXTERN ILvoid iSetInputFile(ILHANDLE File);	48	__FILES_EXTERN ILvoid iSetInputFile(ILHANDLE File);
49	__FILES_EXTERN ILvoid iSetInputLump(ILvoid *Lump, ILuint Size);	49	__FILES_EXTERN ILvoid iSetInputLump(ILvoid *Lump, ILuint Size);
50	__FILES_EXTERN ILboolean (ILAPIENTRY *ieof)(ILvoid);	50	__FILES_EXTERN ILboolean (ILAPIENTRY *ieof)(void);
51	__FILES_EXTERN ILHANDLE (ILAPIENTRY *iopenr)(const ILstring);	51	__FILES_EXTERN ILHANDLE (ILAPIENTRY *iopenr)(const ILstring);
52	__FILES_EXTERN ILvoid (ILAPIENTRY *icloser)(ILHANDLE);	52	__FILES_EXTERN ILvoid (ILAPIENTRY *icloser)(ILHANDLE);
53	__FILES_EXTERN ILint (ILAPIENTRY *igetc)(ILvoid);	53	__FILES_EXTERN ILint (ILAPIENTRY *igetc)(void);
54	__FILES_EXTERN ILuint (ILAPIENTRY iread)(ILvoid Buffer, ILuint Size, ILuint Number);	54	__FILES_EXTERN ILuint (ILAPIENTRY iread)(ILvoid Buffer, ILuint Size, ILuint Number);
55	__FILES_EXTERN ILuint (ILAPIENTRY *iseek)(ILint Offset, ILuint Mode);	55	__FILES_EXTERN ILuint (ILAPIENTRY *iseek)(ILint Offset, ILuint Mode);
56	__FILES_EXTERN ILuint (ILAPIENTRY *itell)(ILvoid);	56	__FILES_EXTERN ILuint (ILAPIENTRY *itell)(void);
57		57
58	__FILES_EXTERN ILvoid iSetOutputFile(ILHANDLE File);	58	__FILES_EXTERN ILvoid iSetOutputFile(ILHANDLE File);
59	__FILES_EXTERN ILvoid iSetOutputLump(ILvoid *Lump, ILuint Size);	59	__FILES_EXTERN ILvoid iSetOutputLump(ILvoid *Lump, ILuint Size);
Lines 61-76 __FILES_EXTERN ILvoid (ILAPIENTRY *iclo Link Here
61	__FILES_EXTERN ILHANDLE (ILAPIENTRY *iopenw)(const ILstring);	61	__FILES_EXTERN ILHANDLE (ILAPIENTRY *iopenw)(const ILstring);
62	__FILES_EXTERN ILint (ILAPIENTRY *iputc)(ILubyte Char);	62	__FILES_EXTERN ILint (ILAPIENTRY *iputc)(ILubyte Char);
63	__FILES_EXTERN ILuint (ILAPIENTRY *iseekw)(ILint Offset, ILuint Mode);	63	__FILES_EXTERN ILuint (ILAPIENTRY *iseekw)(ILint Offset, ILuint Mode);
64	__FILES_EXTERN ILuint (ILAPIENTRY *itellw)(ILvoid);	64	__FILES_EXTERN ILuint (ILAPIENTRY *itellw)(void);
65	__FILES_EXTERN ILint (ILAPIENTRY iwrite)(const ILvoid Buffer, ILuint Size, ILuint Number);	65	__FILES_EXTERN ILint (ILAPIENTRY iwrite)(const ILvoid Buffer, ILuint Size, ILuint Number);
66		66
67	__FILES_EXTERN ILHANDLE ILAPIENTRY iGetFile(ILvoid);	67	__FILES_EXTERN ILHANDLE ILAPIENTRY iGetFile(void);
68	__FILES_EXTERN ILubyte* ILAPIENTRY iGetLump(ILvoid);	68	__FILES_EXTERN ILubyte* ILAPIENTRY iGetLump(void);
69		69
70	__FILES_EXTERN ILuint ILAPIENTRY ilprintf(const char *, ...);	70	__FILES_EXTERN ILuint ILAPIENTRY ilprintf(const char *, ...);
71	__FILES_EXTERN ILvoid ipad(ILuint NumZeros);	71	__FILES_EXTERN ILvoid ipad(ILuint NumZeros);
72		72
73	__FILES_EXTERN ILboolean iPreCache(ILuint Size);	73	__FILES_EXTERN ILboolean iPreCache(ILuint Size);
74	__FILES_EXTERN ILvoid iUnCache(ILvoid);	74	__FILES_EXTERN ILvoid iUnCache(void);
75		75
76	#endif//FILES_H	76	#endif//FILES_H

Lines 38-51 typedef struct PPMINFO Link Here

(-)DevIL-1.6.7/src-IL/include/il_pnm.h (-4 / +4 lines)
38	ILubyte Bpp;	38	ILubyte Bpp;
39	} PPMINFO;	39	} PPMINFO;
40		40
41	ILboolean iIsValidPnm(ILvoid);	41	ILboolean iIsValidPnm(void);
42	ILboolean iCheckPnm(char Header[2]);	42	ILboolean iCheckPnm(char Header[2]);
43	ILboolean iLoadPnmInternal(ILvoid);	43	ILboolean iLoadPnmInternal(void);
44	ILboolean iSavePnmInternal(ILvoid);	44	ILboolean iSavePnmInternal(void);
45	ILimage ilReadAsciiPpm(PPMINFO Info);	45	ILimage ilReadAsciiPpm(PPMINFO Info);
46	ILimage ilReadBinaryPpm(PPMINFO Info);	46	ILimage ilReadBinaryPpm(PPMINFO Info);
47	ILimage ilReadBitPbm(PPMINFO Info);	47	ILimage ilReadBitPbm(PPMINFO Info);
48	ILboolean iGetWord(ILvoid);	48	ILboolean iGetWord(void);
49	ILvoid PbmMaximize(ILimage *Image);	49	ILvoid PbmMaximize(ILimage *Image);
50		50
51		51

Lines 37-45 typedef struct PSDHEAD Link Here

(-)DevIL-1.6.7/src-IL/include/il_psd.h (-3 / +3 lines)
37		37
38	ILushort ChannelNum;	38	ILushort ChannelNum;
39		39
40	ILboolean iIsValidPsd(ILvoid);	40	ILboolean iIsValidPsd(void);
41	ILboolean iCheckPsd(PSDHEAD *Header);	41	ILboolean iCheckPsd(PSDHEAD *Header);
42	ILboolean iLoadPsdInternal(ILvoid);	42	ILboolean iLoadPsdInternal(void);
43	ILboolean ReadPsd(PSDHEAD *Head);	43	ILboolean ReadPsd(PSDHEAD *Head);
44	ILboolean ReadGrey(PSDHEAD *Head);	44	ILboolean ReadGrey(PSDHEAD *Head);
45	ILboolean ReadIndexed(PSDHEAD *Head);	45	ILboolean ReadIndexed(PSDHEAD *Head);
Lines 49-55 ILuint GetCompChanLen(PSDHEAD Head); Link Here
49	ILboolean PsdGetData(PSDHEAD Head, ILvoid Buffer, ILboolean Compressed);	49	ILboolean PsdGetData(PSDHEAD Head, ILvoid Buffer, ILboolean Compressed);
50	ILboolean ParseResources(ILuint ResourceSize, ILubyte *Resources);	50	ILboolean ParseResources(ILuint ResourceSize, ILubyte *Resources);
51	ILboolean GetSingleChannel(PSDHEAD Head, ILubyte Buffer, ILboolean Compressed);	51	ILboolean GetSingleChannel(PSDHEAD Head, ILubyte Buffer, ILboolean Compressed);
52	ILboolean iSavePsdInternal(ILvoid);	52	ILboolean iSavePsdInternal(void);
53		53
54		54
55		55

Lines 232-249 typedef struct ALPHA_CHUNK Link Here

(-)DevIL-1.6.7/src-IL/include/il_psp.h (-8 / +8 lines)
232		232
233		233
234	// Function definitions	234	// Function definitions
235	ILboolean iLoadPspInternal(ILvoid);	235	ILboolean iLoadPspInternal(void);
236	ILboolean iCheckPsp(ILvoid);	236	ILboolean iCheckPsp(void);
237	ILboolean iIsValidPsp(ILvoid);	237	ILboolean iIsValidPsp(void);
238	ILboolean ReadGenAttributes(ILvoid);	238	ILboolean ReadGenAttributes(void);
239	ILboolean ParseChunks(ILvoid);	239	ILboolean ParseChunks(void);
240	ILboolean ReadLayerBlock(ILuint BlockLen);	240	ILboolean ReadLayerBlock(ILuint BlockLen);
241	ILboolean ReadAlphaBlock(ILuint BlockLen);	241	ILboolean ReadAlphaBlock(ILuint BlockLen);
242	ILubyte *GetChannel(ILvoid);	242	ILubyte *GetChannel(void);
243	ILboolean UncompRLE(ILubyte CompData, ILubyte Data, ILuint CompLen);	243	ILboolean UncompRLE(ILubyte CompData, ILubyte Data, ILuint CompLen);
244	ILboolean ReadPalette(ILuint BlockLen);	244	ILboolean ReadPalette(ILuint BlockLen);
245	ILboolean AssembleImage(ILvoid);	245	ILboolean AssembleImage(void);
246	ILboolean Cleanup(ILvoid);	246	ILboolean Cleanup(void);
247		247
248		248
249		249

Lines 25-38 Link Here

(-)DevIL-1.6.7/src-IL/src/il_png.c (-7 / +7 lines)
25	#warning DevIL was designed with libpng 1.2.0 or higher in mind. Consider upgrading at www.libpng.org	25	#warning DevIL was designed with libpng 1.2.0 or higher in mind. Consider upgrading at www.libpng.org
26	#endif	26	#endif
27		27
28	ILboolean iIsValidPng(ILvoid);	28	ILboolean iIsValidPng(void);
29	ILboolean iLoadPngInternal(ILvoid);	29	ILboolean iLoadPngInternal(void);
30	ILboolean iSavePngInternal(ILvoid);	30	ILboolean iSavePngInternal(void);
31	ILvoid pngSwitchData(ILubyte *Data, ILuint SizeOfData, ILubyte Bpc);	31	ILvoid pngSwitchData(ILubyte *Data, ILuint SizeOfData, ILubyte Bpc);
32		32
33	ILint readpng_init(ILvoid);	33	ILint readpng_init(void);
34	ILboolean readpng_get_image(ILdouble display_exponent);	34	ILboolean readpng_get_image(ILdouble display_exponent);
35	ILvoid readpng_cleanup(ILvoid);	35	ILvoid readpng_cleanup(void);
36		36
37	png_structp png_ptr = NULL;	37	png_structp png_ptr = NULL;
38	png_infop info_ptr = NULL;	38	png_infop info_ptr = NULL;
Lines 207-213 ILboolean iLoadPngInternal() Link Here
207		207
208	static ILvoid png_read(png_structp png_ptr, png_bytep data, png_size_t length)	208	static ILvoid png_read(png_structp png_ptr, png_bytep data, png_size_t length)
209	{	209	{
210	(ILvoid)png_ptr;	210	(void)png_ptr;
211	iread(data, 1, length);	211	iread(data, 1, length);
212	return;	212	return;
213	}	213	}
Lines 455-461 ILboolean ilSavePngL(ILvoid *Lump, ILuin Link Here
455		455
456	ILvoid png_write(png_structp png_ptr, png_bytep data, png_size_t length)	456	ILvoid png_write(png_structp png_ptr, png_bytep data, png_size_t length)
457	{	457	{
458	(ILvoid)png_ptr;	458	(void)png_ptr;
459	iwrite(data, 1, length);	459	iwrite(data, 1, length);
460	return;	460	return;
461	}	461	}