fs/ras/fsDraw.h

Go to the documentation of this file.

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
/*                          _______      ______    ______          __      */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~    / ____(_)___ / ___ /)  / ____/___  ____/ /__    */
/*      [fsDraw]          / /_  / / __ \\__ \|/  / /   / __ \/ __  / _ \   */
/*       rev.  3         / __/ / / /_/ /__/ /   / /___/ /_/ / /_/ /  __/   */
/*    26th May 2006     /_/   /_/ ,___/____/    \____/\____/\__,_/\___/    */
/*     [ ] stable              /_/ (c) 2006 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_FSDRAW_H
#define FS_RAS_FSDRAW_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 nsDraw {
//---------------------------------------------------------------------------
struct PxFmt8888_t { unsigned char r, g, b, a; };
//---------------------------------------------------------------------------
struct Cl8888DwPcy_t
{
    typedef PxFmt8888_t PxFmt_t;
};
//---------------------------------------------------------------------------
} // namespace nsDraw
//---------------------------------------------------------------------------

template <typename TDwPcy>
void DrawLine(int nX1, int nY1, int nX2, int nY2, const nsDraw::PxFmt8888_t
 &Clr, typename TDwPcy::PxFmt_t *pDst, int nDstW, int nDstH)
{
    FS_ASSERT(pDst);
    FS_ASSERT(nDstW > 0 && nDstH > 0);
    
    if(
     nX1 < 0 || nY1 < 0 || nY2 < 0 || nX2 < 0 ||
     nX1 >= nDstW || nY1 >= nDstH ||
     nX2 >= nDstW || nY2 >= nDstH
    ) return; // no clipping at the moment

    struct Abs { static int Do(int v) { return v >= 0 ? v : -v; }};
    
    int nDX = Abs::Do(nX2 - nX1);
    int nDY = Abs::Do(nY2 - nY1);

    bool bSteep = nDY > nDX;
    if(bSteep)
    {
        struct Swap { static void Do(int &v1, int &v2)
        { int t = v1; v1 = v2; v2 = t; }};
    
        Swap::Do(nDX, nDY);
        Swap::Do(nX1, nY1);
        Swap::Do(nX2, nY2);
    }

    int nError = 0;
    int nDE = nDY;
    int &x = bSteep ? nY1 : nX1;
    int &y = bSteep ? nX1 : nY1;
    int nStepX = (nX1 < nX2) ? 1 : -1;
    int nStepY = (nY1 < nY2) ? 1 : -1;
        
    typedef typename TDwPcy::PxFmt_t Px_t;
    Px_t Px(Clr);

    FS_ASSERT(x >= 0 && y >= 0 && x < nDstW && y < nDstH);
    pDst[y * nDstW + x] = Px;
    
    while(nX1 != nX2)
    {
        nX1 += nStepX;
        nError += nDE;
        if((nError << 1) >= nDX)
        {
            nY1 += nStepY;
            nError -= nDX;
        }
        
        FS_ASSERT(x >= 0 && y >= 0 && x < nDstW && y < nDstH);
        pDst[y * nDstW + x] = Px;
    }
}
//---------------------------------------------------------------------------

template <typename TDwPcy>
void DrawCirc(int nX, int nY, int nR, const nsDraw::PxFmt8888_t &Clr,
 typename TDwPcy::PxFmt_t *pDst, int nDstW, int nDstH)
{
    FS_ASSERT(pDst);
    FS_ASSERT(nDstW > 0 && nDstH > 0);

    if(
     nX < nR || nY < nR ||
     nX >= nDstW - nR || nY >= nDstH - nR
    ) return; // no clipping at the moment

    int x = 0;
    int y = nR;
    int nD = 3 - (2 * nR);
    
    typedef typename TDwPcy::PxFmt_t Px_t;
    Px_t Px(Clr);
    
    struct Offset
    {
        int m_w, m_h;
        Offset(int w, int h) : m_w(w), m_h(h) {}
        int Do(int x, int y) const
        {
            FS_ASSERT(x >= 0 && y >= 0 && x < m_w && y < m_h);
            return y * m_w + x;
        }
    };
    
    const Offset Off(nDstW, nDstH);
    while(x <= y)
    {
        pDst[Off.Do(nX + y, nY + x)] = Px;
        pDst[Off.Do(nX - y, nY + x)] = Px;
        pDst[Off.Do(nX + y, nY - x)] = Px;
        pDst[Off.Do(nX - y, nY - x)] = Px;
        pDst[Off.Do(nX + x, nY + y)] = Px;
        pDst[Off.Do(nX - x, nY + y)] = Px;
        pDst[Off.Do(nX + x, nY - y)] = Px;
        pDst[Off.Do(nX - x, nY - y)] = Px;
        
        if(nD < 0) nD += (4 * x) + 6;
        else { nD += (4 * (x - y)) + 10; --y; }
        ++x;
    }
}
//---------------------------------------------------------------------------
}} // namespace fs::ras
//---------------------------------------------------------------------------
#endif // FS_RAS_FSDRAW_H

---

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