|| || || || || || || ||

---

OglImageCache.h

Go to the documentation of this file.

#ifndef OglGui_OglImageCache_h
#define OglGui_OglImageCache_h

/*
 ******************************************************************************
    OglGui::OglImageCache: Maintain a LRU list of OGLIMAGE * objects.

    The OglImageCache increments the refCount of each
    added OGLIMAGE*, adding these to the cache until the
    cache is full.

    When an OGLIMAGE* is added and the cache is full, the
    refCount of the Least Recently Used OGLIMAGE is decremented
    (resulting in its destruction when no others are referencing it)
    and its slot in the cache is replaced by the new OGLIMAGE*.

    Use AddNoScalingTextured(OGLIMAGE* im, int id) to reuse cached
    existing textures based on the noTexScaling speed-up feature of OGL.
    In this case an unused OGLIMAGE with the correct texture size
    is searched for in the cache. Its texture is re-used and the unused
    image is destroyed. (See mainDirImViewer3D for an example of use)

    NOTE: When an OGLIMAGE* is obtained from the cache, its refCount
    is incremented. Therefore, the caller must release the obtained
    OGLIMAGE* when it is no longer needed.

 ******************************************************************************
 *  Example Caller:
 ******************************************************************************
    main()
    {
        Init(100);
    }

    void Init(int size)
    {
        mOglImageCache = new OglGui::OglImageCache(size);
        RandomRead(10000, 1000);
    }

    void RandomRead(int n, int maxId)
    {
        for (int i=0; i<n; i++)
        {
            OGLIMAGE* oglIm = LoadImageIdx("../images", ABSRND(maxId));
            if (oglIm)
                ReleaseOglImage(oglIm);
        }
    }

    OGLIMAGE* LoadImageIdx(char* path, int id)
    {
        OGLIMAGE* im;
        if (! (im = mOglImageCache->GetImage(id)) )
        {
            char buf[1024];
            sprintf(buf, "%s/image%d.png", path, id);
            if (im = OGLReadPNG(buf))
                mOglImageCache->Add(im, id);
        }
        else
            printf("Cache hit for image%d\n", id);
        return im;
    }
*******************************************************************************
*/

#ifndef OGLIMAGE_H
#include "Link/OGL/OGLImage.h"
#endif

#include <vector>
#include <list>

extern "C" {
unsigned char        IsPower2( int num, int *nearest );
}

namespace OglGui {

class OglImageCache
{
public:
    typedef std::pair<OGLIMAGE*, unsigned long long>       ImIdPair;

    OglImageCache(int size)
    {
        Init(size);
    }

    ~OglImageCache()
    {
        int sz = mImages.size();
        for (int i=0; i<sz; i++)
        {
            ImIdPair* p = mImages[i];
            if (p->first)
                ReleaseOglImage(p->first);
            delete p;
        }
        mImages.clear();
    }

    OGLIMAGE* GetImage(unsigned long long id)
    {
        ImIdPair* imIdPair = GetImIdPair(id);
        if (imIdPair)
        {
            OGLIMAGE* oglIm = imIdPair->first;
            if (oglIm)
                oglIm->refCount++;
            return oglIm;
        }
        return 0;
    }

    void AddNoScalingTextured(OGLIMAGE* im, unsigned long long id)
    {
        if (!im)
            return;

        int texW, texH;
        IsPower2(im->w, &texW);
        IsPower2(im->h, &texH);

        ImIdPair* p;
        if (!im->texture && (p = GetUnusedImIdPairWithTexSize(texW, texH))!=0)
        {
            OGLIMAGE* texIm = p->first;
            int tex = texIm->texture;
            texIm->texture = 0;
            ReleaseOglImage(texIm);

            im->texture = tex;
            im->refCount++;

            p->second = id;
            p->first  = im;
        }
        else
            Add(im, id);

        im->noTexScaling = 1;
        im->texW = texW;
        im->texH = texH;
        im->changed = 1;
    }

    void Add(OGLIMAGE* im, unsigned long long id, bool allowReplace=false)
    {
        ImIdPair* p = 0;

        if (allowReplace)
            p = GetImIdPair(id);
        if (!p)
            p = GetLRU();
        if (im)
            im->refCount++;
        if (p->first)
            ReleaseOglImage(p->first);
        p->first   = im;
        p->second  = id;
    }

private:

    ImIdPair* GetImIdPair(unsigned long long id)
    {
        for (int i=0; i<mImages.size(); i++)
        {
            if (id == mImages[i]->second)
            {
                UpdateLRU(i);
                return mImages[i];
            }
        }
        return 0;
    }

    ImIdPair* GetUnusedImIdPairWithTexSize(int texW, int texH)
    {
        OGLIMAGE* im;
        for (int i=0; i<mImages.size(); i++)
        {
            if ((im = mImages[i]->first) && im->refCount==1 &&
                im->texture && im->texW == texW && im->texH == texH)
            {
                UpdateLRU(i);
                return mImages[i];
            }
        }
        return 0;
    }

    void UpdateLRU(int index)
    {
        mLRU.remove(index);
        mLRU.push_back(index);
    }

    ImIdPair* GetLRU()
    {
        int item = mLRU.front();
        UpdateLRU(item);
        return mImages[item];
    }

    void Init(int size)
    {
        mCacheSize = size;

        for (int i=0; i<mCacheSize; i++)
        {
            mImages.push_back(new ImIdPair(0,-1));
            mLRU.push_back(i);
        }
    }

    std::list<int>            mLRU;
    std::vector<ImIdPair*>    mImages;

    int                       mCacheSize;
};

} // namespace OglGui

#endif // OglGui_OglImageCache_h

---