fs/ras/fsRle8Blt.h

Go to the documentation of this file.

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
/*                          _______      ______    ______          __      */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~    / ____(_)___ / ___ /)  / ____/___  ____/ /__    */
/*     [fsRle8Blt]        / /_  / / __ \\__ \|/  / /   / __ \/ __  / _ \   */
/*       rev. 3          / __/ / / /_/ /__/ /   / /___/ /_/ / /_/ /  __/   */
/*    6th Feb 2007      /_/   /_/ ,___/____/    \____/\____/\__,_/\___/    */
/*     [ ] stable              /_/ (c) 2006-7 Filip STOKLAS (FipS)         */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~       http://HOLE.4FipS.com/fips_code.php          */
/*                                                                         */
/* This code is free for personal and commercial use. You may redistribute */
/* it by any means. If you use the code for your own projects please give  */
/* me credit. Please send a bug report. Don't alter or remove this header! */
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#ifndef FS_RAS_FSRLE8BLT_H
#define FS_RAS_FSRLE8BLT_H
//---------------------------------------------------------------------------
#if defined(FS_INCLUDE_USERDEFS) // inject user definition file on request
#   include <fs/fsUserDefs.h>
#endif 

#if defined(FS_HAS_FSASSERT)
#   include <fs/utils/fsAssert.h>
#else
#   include <cassert>
#   if !defined(FS_ASSERT)
#       define FS_ASSERT(exp) assert(exp)
#   endif
#   if !defined(FS_ASSERT_MSG)
#       define FS_ASSERT_MSG(exp, msg) assert(exp)
#   endif
#   if !defined(FS_STATIC_ASSERT)
#       define FS_STATIC_ASSERT(exp) { char array[(exp) ? 1 : 0]; array; }
#   endif
#endif
//---------------------------------------------------------------------------
namespace fs { namespace ras {
//---------------------------------------------------------------------------
namespace nsRle8Blt {
//---------------------------------------------------------------------------
struct PxFmt8888_t { unsigned char r, g, b, a; };
typedef unsigned int uint32;
//---------------------------------------------------------------------------
struct Cl8888TrCpPcy_t
{
    typedef PxFmt8888_t SrcPxFmt_t;
    typedef PxFmt8888_t DstPxFmt_t;
    static void Copy(const SrcPxFmt_t &Src, DstPxFmt_t &Dst)
    {
        FS_STATIC_ASSERT(sizeof(SrcPxFmt_t) == 4);
        FS_STATIC_ASSERT(sizeof(DstPxFmt_t) == 4);
        Dst = Src;
    }
};
//---------------------------------------------------------------------------
struct Cl8888BlCpPcy_t
{
    typedef PxFmt8888_t SrcPxFmt_t;
    typedef PxFmt8888_t DstPxFmt_t;
    static void Copy(const SrcPxFmt_t &Src, DstPxFmt_t &Dst)
    {
        FS_STATIC_ASSERT(sizeof(SrcPxFmt_t) == 4);
        FS_STATIC_ASSERT(sizeof(DstPxFmt_t) == 4);

        const float a = Src.a / 255.f;
        const float b = (255 - Src.a) / 255.f;
        Dst.r = static_cast<unsigned char>(a * Src.r + b * Dst.r);
        Dst.g = static_cast<unsigned char>(a * Src.g + b * Dst.g);
        Dst.b = static_cast<unsigned char>(a * Src.b + b * Dst.b);
    }
};
//---------------------------------------------------------------------------
} // namespace nsRle8Blt
//---------------------------------------------------------------------------

template <typename TCpPcy>
void Rle8Blt(
 const unsigned char *pRle,
 const nsRle8Blt::PxFmt8888_t *pPal,
 const nsRle8Blt::uint32 *pOff,
 int nSrcW,
 int /*nSrcH*/,
 int nRegW,
 int nRegH,
 typename TCpPcy::DstPxFmt_t *pDst,
 int nDstW,
 int nDstH,
 int nDstPosX,
 int nDstPosY,
 int nDstClipX1 = 0,
 int nDstClipY1 = 0,
 int nDstClipX2 = -1, // -1 stands for nDstW
 int nDstClipY2 = -1  // -1 stands for nDstH
)
{
    FS_ASSERT(pRle);
    FS_ASSERT(pPal);
    FS_ASSERT(pOff);
    
    typedef typename TCpPcy::SrcPxFmt_t SrcPxFmt_t;
    typedef typename TCpPcy::DstPxFmt_t DstPxFmt_t;
            
    //--- PREPARE BUFFERS ---
    
    const nsRle8Blt::uint32 *pDstOffCur = pOff;
    DstPxFmt_t *pDstLnCur = pDst + nDstPosY * nDstW + nDstPosX;
        
    //--- APPLY CLIPPING ---
    
    nDstClipX2 = nDstClipX2 != -1 ? nDstClipX2 : nDstW;
    nDstClipY2 = nDstClipY2 != -1 ? nDstClipY2 : nDstH;

    // right
    if(nDstPosX + nRegW > nDstClipX2)
    {
        nRegW = nDstClipX2 - nDstPosX;
    }

    // bottom
    if(nDstPosY + nRegH > nDstClipY2)
    {
        nRegH = nDstClipY2 - nDstPosY;
    }    

    // left
    if(nDstPosX < nDstClipX1)
    {
        const int nLeftClip = nDstClipX1 - nDstPosX;
        nRegW -= nLeftClip;
        pDstLnCur += nLeftClip;
    }

    // top
    if(nDstPosY < nDstClipY1)
    {
        const int nTopClip = nDstClipY1 - nDstPosY;
        nRegH -= nTopClip;
        pDstLnCur += nTopClip * nDstW;
        pDstOffCur += nTopClip;
    }

    if(nRegW <= 0 || nRegH <= 0)
        return; // out of the clipping region
    
    //--- TRANSFER DATA ---
    
    for(int y = nRegH; y != 0; --y)
    {
        const unsigned char *pRleCur = pRle + *pDstOffCur;
        DstPxFmt_t *pDstCur = pDstLnCur;
        
        int x = nDstPosX; // cur pos in dst space
        unsigned char uN = (*pRleCur) >> 1; FS_ASSERT(uN > 0);
        bool bTr = ((*pRleCur) & 1) == 0;
        
        //--- LEFT CLIP ---

        if(nDstPosX < nDstClipX1)
        {
            for(;;)
            {
                // the segment intersects the left bound, cut it
                if(x + uN > nDstClipX1)
                {
                    // skip the left part
                    pRleCur += bTr ? 0 : nDstClipX1 - x;
                
                    uN = static_cast<unsigned char>(x + uN - nDstClipX1);
                    
                    x = nDstClipX1;
                    break;
                }
                // skip the whole segment
                else
                {
                    x += uN;
                    pRleCur += bTr ? 1 : uN + 1;
                                            
                    uN = (*pRleCur) >> 1;
                    bTr = ((*pRleCur) & 1) == 0;
                }
            }
        }
        
        //--- BODY ---
                        
        const int nDataX = nDstPosX + nSrcW;
        const int nStopX = nDataX < nDstClipX2 ? nDataX : nDstClipX2;
        
        while(x + uN < nStopX)
        {
            ++pRleCur;
        
            if(bTr) // skip the transparent segment
            {
                x += uN;
                pDstCur += uN;
            }
            else // copy the segment
            {
                for(int j = 0; j < uN; ++j)
                {
                    TCpPcy::Copy(pPal[*pRleCur], *pDstCur);

                    ++x;
                    ++pRleCur;
                    ++pDstCur;
                }
            }
            
            uN = (*pRleCur) >> 1;
            bTr = ((*pRleCur) & 1) == 0;
        }
        
        //--- COMPLETE RIGHT CLIP ----
        
        if(x < nStopX && !bTr)
        {
            ++pRleCur;
            
            for(;x < nStopX; ++x)
            {
                TCpPcy::Copy(pPal[*pRleCur], *pDstCur);
                
                ++pRleCur;
                ++pDstCur;
            }
        }
        
        //---
        
        ++pDstOffCur;
        pDstLnCur += nDstW;
    }
}
//---------------------------------------------------------------------------
}} // namespace fs::ras
//---------------------------------------------------------------------------
#endif // FS_RAS_FSRLE8BLT_H

---

FipS' Code (Thu Feb 15 22:43:35 2007) - (c) Filip STOKLAS (FipS) - [ www ] [ Guest Book ]