glfxil.h

/*-------------------------------------------------------------------------
This source code is part of GLfx library (OpenGL effect library)
For more information and updates see http://glfx.sourceforge.net/
Copyright (C) 2005-6 Tomek Rozen <trozen at users sourceforge net>

This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License,
or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
for more details.
-------------------------------------------------------------------------*/

#ifndef __GLFXIL_H__
#define __GLFXIL_H__

#include <IL/il.h>

#ifdef _MSC_VER
#pragma comment(lib, "DevIL")
#endif

namespace GLFX {

class EffectManager_DevIL : public EffectManager
{
public:

    EffectManager_DevIL() {
        ilInit();
        ilSetRead(0, 0, MyEofProc, MyGetcProc, MyReadProc, MySeekProc, MyTellProc);
        ilEnable(IL_ORIGIN_SET);
        ilOriginFunc(IL_ORIGIN_LOWER_LEFT);
        MessageFormat(LOG_NOTICE, "This program uses DevIL (Developers Image Library) version %d, (C) %s.",
            ilGetInteger(IL_VERSION_NUM), ilGetString(IL_VENDOR));
    }

    ~EffectManager_DevIL() {
        ilShutDown();
    }

    bool FillTextureData(GLenum target, const char* name) {
        if(EffectManager::FillTextureData(target, name)) {
            return true;
        }
        if(target == GL_TEXTURE_1D) {
            return false;
        } else if(target == GL_TEXTURE_3D) {
            return false;
        } else if(target == GL_TEXTURE_CUBE_MAP) {
            return false;
        } else {
            FileHandle file;
            file.fxMgr = this;
            file.file = OpenFile(name, false);
            bool ok = false;
            if(file.file) {
                ILuint image;
                ilGenImages(1, &image);
                ilBindImage(image);
                if(ilLoadF(IL_TYPE_UNKNOWN, (ILHANDLE)&file))
                {
                    ILint width = ilGetInteger(IL_IMAGE_WIDTH);
                    ILint height = ilGetInteger(IL_IMAGE_HEIGHT);
                    GLint glcomp;
                    GLenum glformat;
                    ILenum ilformat = ilGetInteger(IL_IMAGE_FORMAT);
                    switch(ilformat)
                    {
                    case IL_LUMINANCE:
                        glformat = GL_LUMINANCE;
                        glcomp = 1;
                        break;
                    case IL_LUMINANCE_ALPHA:
                        glformat = GL_LUMINANCE_ALPHA;
                        glcomp = 2;
                        break;
                    default:
                        glformat = GL_BGRA;
                        ilformat = IL_BGRA;
                        glcomp = 4;
                        break;
                    }

                    ilConvertImage(ilformat, IL_UNSIGNED_BYTE);
                    GLubyte* data = ilGetData();

                    gluBuild2DMipmaps(target, 4, width, height, GL_BGRA, GL_UNSIGNED_BYTE, data);

                    ok = true;
                }
                // Unbind and delete image
                ilBindImage(0);
                ilDeleteImages(1, &image);
                CloseFile(file.file);
            }
            if(!ok) {
                return false;
            }
            return true;
        }
    }

private:

    struct FileHandle
    {
        EffectManager_DevIL* fxMgr;
        void* file;
    };

    static ILboolean ILAPIENTRY MyEofProc(ILHANDLE handle) {
        FileHandle* fh = (FileHandle*)handle;
        fh->fxMgr->Eof(fh->file);
        return false;
    }

    static ILint ILAPIENTRY MyGetcProc(ILHANDLE handle) {
        unsigned char c;
        FileHandle* fh = (FileHandle*)handle;
        if(fh->fxMgr->ReadFile(fh->file, &c, 1) != 1) {
            return EOF;
        }
        return c;
    }

    static ILint ILAPIENTRY MyReadProc(void *buffer, ILuint size, ILuint count, ILHANDLE handle) {
        FileHandle* fh = (FileHandle*)handle;
        return fh->fxMgr->ReadFile(fh->file, buffer, size * count);
    }

    static ILint ILAPIENTRY MySeekProc(ILHANDLE handle, ILint offset, ILint origin) {
        FileHandle* fh = (FileHandle*)handle;
        return fh->fxMgr->SeekFile(fh->file, offset, origin);
    }

    static ILint ILAPIENTRY MyTellProc(ILHANDLE handle) {
        FileHandle* fh = (FileHandle*)handle;
        return fh->fxMgr->TellFile(fh->file);
    }
};

}

#endif // __GLFXIL_H__

---