fs/ras/fsBitBlt.h

Go to the documentation of this file.

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
/*                          _______      ______    ______          __      */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~    / ____(_)___ / ___ /)  / ____/___  ____/ /__    */
/*     [fsBitBlt]         / /_  / / __ \\__ \|/  / /   / __ \/ __  / _ \   */
/*       rev. 6          / __/ / / /_/ /__/ /   / /___/ /_/ / /_/ /  __/   */
/*    6th Feb 2007      /_/   /_/ ,___/____/    \____/\____/\__,_/\___/    */
/*     [x] 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_FSBITBLT_H
#define FS_RAS_FSBITBLT_H
//---------------------------------------------------------------------------
#if defined(FS_INCLUDE_USERDEFS) // inject user definition file on request
#   include <fs/fsUserDefs.h>
#endif
//---------------------------------------------------------------------------
// >>> COMMON SUPPORT BLOCK (rev. 6)
#if defined(FS_HAS_FSASSERT)
#   include <fs/sys/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 && msg)
#   endif
#   if !defined(FS_VERIFY)
#       define FS_VERIFY(exp) \
        { bool bExp = !!(exp); assert(bExp && #exp); bExp; }
#   endif
#   if !defined(FS_VERIFY_MSG)
#       define FS_VERIFY_MSG(exp, msg) \
        { bool bExp = !!(exp); assert(bExp && #exp && msg); bExp; }
#   endif
#   if !defined(FS_STATIC_ASSERT)
#       define FS_STATIC_ASSERT(exp) { char error[(exp) ? 1 : 0]; error; }
#   endif
#endif
#if !defined(FS_VERIFY_RETURN)
#   define FS_VERIFY_RETURN(exp) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<return>"); return; }
#endif
#if !defined(FS_VERIFY_RETURN_VAL)
#   define FS_VERIFY_RETURN_VAL(exp, ret) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<returns:>" #ret); return (ret); }
#endif
// <<< COMMON SUPPORT BLOCK (rev. 6)
//---------------------------------------------------------------------------
namespace fs { namespace ras {
//---------------------------------------------------------------------------
namespace nsBitBlt {
//---------------------------------------------------------------------------
struct PxFmt888_t { unsigned char r, g, b; };
struct PxFmt8888_t { unsigned char r, g, b, a; };
//---------------------------------------------------------------------------
struct Cl888CpPcy_t
{
    typedef PxFmt888_t SrcPxFmt_t;
    typedef PxFmt888_t DstPxFmt_t;
    static void Copy(const SrcPxFmt_t &Src, DstPxFmt_t &Dst)
    {
        FS_STATIC_ASSERT(sizeof(SrcPxFmt_t) == 3);
        FS_STATIC_ASSERT(sizeof(DstPxFmt_t) == 3);
        Dst = Src;
    }
};
//---------------------------------------------------------------------------
struct Cl8888CpPcy_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 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.a ? Src : Dst;
    }
};
//---------------------------------------------------------------------------
struct Cl888to8888CpPcy_t
{
    typedef PxFmt888_t SrcPxFmt_t;
    typedef PxFmt8888_t DstPxFmt_t;

    static void Copy(const SrcPxFmt_t &Src, DstPxFmt_t &Dst)
    {
        FS_STATIC_ASSERT(sizeof(SrcPxFmt_t) == 3);
        FS_STATIC_ASSERT(sizeof(DstPxFmt_t) == 4);
        Dst.r = Src.r;
        Dst.g = Src.g;
        Dst.b = Src.b;
    }
};
//---------------------------------------------------------------------------
} // namespace nsBitBlt
//---------------------------------------------------------------------------

template <typename TCpPcy>
void BitBlt(
 typename const TCpPcy::SrcPxFmt_t *pSrc,
 int nSrcW,
 int /*nSrcH*/,
 int nSrcPosX,
 int nSrcPosY,
 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(pSrc && pDst);
    
    //--- PREPARE BUFFERS ---
    
    typedef typename TCpPcy::SrcPxFmt_t SrcPxFmt_t;
    typedef typename TCpPcy::DstPxFmt_t DstPxFmt_t;
    
    const SrcPxFmt_t *pSrcCur = pSrc + nSrcPosY * nSrcW + nSrcPosX;
    DstPxFmt_t *pDstCur = 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;
        pSrcCur += nLeftClip;
        pDstCur += nLeftClip;
    }

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

    if(nRegW <= 0 || nRegH <= 0)
        return; // out of the clipping region

    //--- TRANSFER DATA ---

    const int nSrcSkip = nSrcW - nRegW;
    const int nDstSkip = nDstW - nRegW;

    for(int y = nRegH; y != 0; --y)
    {
        for(int x = nRegW; x != 0; --x)
        {
            TCpPcy::Copy(*pSrcCur, *pDstCur);
            ++pSrcCur;
            ++pDstCur;
        }

        pSrcCur += nSrcSkip;
        pDstCur += nDstSkip;
    }
}
//---------------------------------------------------------------------------
}} // namespace fs::ras
//---------------------------------------------------------------------------
#endif // FS_RAS_FSBITBLT_H

---

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