gfx_types.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2004 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#ifndef GFX_TYPES_HH
#define GFX_TYPES_HH 1

#include "gfx_types_vertex.hh"

namespace gfx {

// Basic types must be fast.  Virtual functions incur overhead from C++ vtable.
#define virtual VIRTUAL_METHODS_IN_BASIC_TYPES_IS_TOO_SLOW

template<typename T>
struct WidthHeight
{
    WidthHeight( void ) : w(0), h(0) { }
    WidthHeight( T W, T H ) : w(W), h(H) { }
    T   w, h;
};

template<typename T>
class Rect
{
public:
    Rect( void )
    :   x1(0), y1(0), x2(0), y2(0)
    {
        // NOP
    }

    Rect( T X1, T Y1, T X2, T Y2 )
//  :   x1(X1), y1(Y1), x2(X2), y2(Y2)  // use Set() which can correct args
    {
        Set( X1, Y1, X2, Y2 );
    }

    void Set( T X1, T Y1, T X2, T Y2 )
    {
        // Try to maintain assumption that (x1,y1) < (x2,y2).
        x1 = MIN( X1, X2 );
        y1 = MIN( Y1, Y2 );
        x2 = MAX( X1, X2 );
        y2 = MAX( Y1, Y2 );
    }

    bool IfZero( void ) const
    {
      //return (x1 + y1 + x2 + y2) == 0;  // pos/neg values could cancel each other
        return (ABS(x1) + ABS(y1) + ABS(x2) + ABS(y2)) == 0;
    }

    bool IfInside( T x, T y ) const
    {
        return    x >= x1   // assumes (x1,y1) < (x2,y2)
               && x <= x2   // this could be recoded to not assume
               && y >= y1   // but it'd be slower
               && y <= y2;
    }

    bool IfInside( const Vector2& v ) const
    {
        return IfInside( T(v.x), T(v.y) );  // cast to suppress warning
    }

    bool IfOutside( const Rect<T>& rect ) const
    {
        return x2 < rect.x1     // if this right side is left of other
            || x1 > rect.x2     // if this left side is right of other
            || y1 > rect.y2     // if top of this is below other
            || y2 < rect.y1;    // if bottom of this is above other
    }

    bool IfOverlaps( const Rect& rect ) const
    {
        // Not outside means entirely inside or partially inside (overlap).
        return not IfOutside( rect );
    }

    void Grow( T x, T y )
    {
        // Try to maintain assumption that (x1,y1) < (x2,y2).
        x1 = MIN(x1,x);
        y1 = MIN(y1,y);
        x2 = MAX(x2,x);
        y2 = MAX(y2,y);
    }

    T GetWidth( void ) const
    {
        return x2 - x1;  // right - left
    }

    T GetHeight( void ) const
    {
        return y2 - y1;  // bottom - top
    }

public:
    T   x1;  // smallest x (NW)
    T   y1;  // smallest y
    T   x2;  // greatest x (SE)
    T   y2;  // greatest y
};

template<typename T>
bool operator==( const Rect<T>& a, const Rect<T>& b )
{
    return a.x1 == b.x1
        && a.y1 == b.y1
        && a.x2 == b.x2
        && a.y2 == b.y2;
}

template<typename T>
bool operator!=( const Rect<T>& a, const Rect<T>& b )
{
    return ! (a == b);
}

template<typename T>
bool operator<( const Rect<T>& a, const Rect<T>& b )
{
    RETURN_LT_TRUE_GT_FALSE( a.x1, b.x1 )
    RETURN_LT_TRUE_GT_FALSE( a.y1, b.y1 )
    RETURN_LT_TRUE_GT_FALSE( a.x2, b.x2 )
    RETURN_LT_TRUE_GT_FALSE( a.y2, b.y2 )
    return false;  // equal
}

template<typename T>
ostream&
operator<<( ostream& strm, const Rect<T>& o )
{
    ios::fmtflags savedFlags = strm.flags();
    strm << '{'
         << "x1=" << OMANIP_FIELD(0) << o.x1 << ','
         << "y1=" << OMANIP_FIELD(0) << o.y1 << ','
         << "x2=" << OMANIP_FIELD(0) << o.x2 << ','
         << "y2=" << OMANIP_FIELD(0) << o.y2 << '}';
    strm.flags(savedFlags);
    return strm;
}

#undef virtual

} // namespace gfx

#endif // GFX_TYPES_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:11 2007