glfxfi.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 __GLFXFI_H__
#define __GLFXFI_H__

#include <FreeImage.h>

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

namespace GLFX {

class EffectManager_FreeImage : public EffectManager
{
public:

    EffectManager_FreeImage() {
#ifdef LINUX
        FreeImage_Initialise(FALSE);
#endif
        ErrorReportingInstance(this, true);
        FreeImage_SetOutputMessage(MyFreeImageErrorHandler);
        MessageFormat(LOG_NOTICE, "Initialising FreeImage %s: %s.",
            FreeImage_GetVersion(), FreeImage_GetCopyrightMessage());
    }

    ~EffectManager_FreeImage() {
#ifdef LINUX
        FreeImage_DeInitialise();
#endif
    }

    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 {
            FreeImageIO io;
            io.read_proc  = MyReadProc;
            io.write_proc = MyWriteProc;
            io.seek_proc  = MySeekProc;
            io.tell_proc  = MyTellProc; 
            FileHandle file;
            file.fxMgr = this;
            file.file = OpenFile(name, false);
            bool ok = false;
            if(file.file) {
                FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)&file, 0); 
                //FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(name, 0);
                if(fif != FIF_UNKNOWN) {
                    // load from the file handle
                    // TODO handle luminance images
                    FIBITMAP* dib = FreeImage_LoadFromHandle(fif, &io, (fi_handle)&file, 0);
                    FIBITMAP* dib32 = FreeImage_ConvertTo32Bits(dib);

                    int width = FreeImage_GetWidth(dib32);
                    int height = FreeImage_GetHeight(dib32);
                    void* data = FreeImage_GetBits(dib32);

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

                    ok = true;

                    // free the loaded FIBITMAP
                    FreeImage_Unload(dib);
                    FreeImage_Unload(dib32);
                }
                CloseFile(file.file);
            }
            if(!ok) {
                return false;
            }
            return true;
        }
    }

private:

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

    static EffectManager* ErrorReportingInstance(EffectManager* mgr = 0, bool setMgr = false) {
        static EffectManager* manager = 0;
        if(setMgr) {
            manager = mgr;
        }
        return manager;
    }

    static unsigned DLL_CALLCONV MyReadProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
        FileHandle* fh = (FileHandle*)handle;
        return fh->fxMgr->ReadFile(fh->file, buffer, size * count);
    }

    static unsigned DLL_CALLCONV MyWriteProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
        return 0;
    }

    static int DLL_CALLCONV MySeekProc(fi_handle handle, long offset, int origin) {
        FileHandle* fh = (FileHandle*)handle;
        return fh->fxMgr->SeekFile(fh->file, offset, origin);
    }

    static long DLL_CALLCONV MyTellProc(fi_handle handle) {
        FileHandle* fh = (FileHandle*)handle;
        return fh->fxMgr->TellFile(fh->file);
    }

    static void MyFreeImageErrorHandler(FREE_IMAGE_FORMAT fif, const char *message) {
        EffectManager* inst = ErrorReportingInstance();
        inst->MessageFormat(LOG_ERROR, "%s format: %s", FreeImage_GetFormatFromFIF(fif), message);
    }

};

}

#endif // __GLFXFI_H__

---