Fixed.hpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// Project: uLib
// Module: Basic support for the FIXED type used in GDI.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD decendant)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

#ifdef __cplusplus
#ifndef __Fixed_hpp_incl__
#define __Fixed_hpp_incl__

#include <uLib/Common.h>


struct Fixed : FIXED
{
    // WORD  fract;
    // short value;

    #define _LT    LITERAL( long, *this ) // Long (this)
    #define _LL(x) LITERAL( long, x )     // Literal long
    #define _F1    (1 << 16)              // Fixed integer 1

    Fixed( void ) { _LT = 0; }
    Fixed( const float val ) { *this = val; }  // Call opr = (float)
    Fixed( const Fixed& val ) { *this = val; } // Call opr = (Fixed)
    //Fixed( const short val ) { value = val; fract = 0; } // Annoying ambiguity..

    operator float() const { return float(_LT) / _F1; } // Note: Limited precision!

    Fixed& operator = ( const short val )  { value = val; fract = 0; return *this; }
    Fixed& operator = ( const Fixed& val ) { _LT = _LL( val ); return *this; }
    Fixed& operator = ( const FIXED& val ) { _LT = _LL( val ); return *this; }
    Fixed& operator = ( const float val )  { _LT = long( val * _F1 ); return *this; }

    Fixed& operator += ( const short rhs ) { value += rhs; return *this; }
    Fixed& operator -= ( const short rhs ) { value -= rhs; return *this; }
    Fixed& operator *= ( const short rhs ) { _LT *= rhs; return *this; }
    Fixed& operator /= ( const short rhs ) { _LT /= rhs; return *this; }
    Fixed& operator %= ( const short rhs ) { _LT %= long(rhs) << 16; return *this; }

    Fixed& operator += ( const Fixed& rhs ) { _LT += _LL( rhs ); return *this; }
    Fixed& operator -= ( const Fixed& rhs ) { _LT -= _LL( rhs ); return *this; }
    Fixed& operator *= ( const Fixed& rhs ) { _LT = long( (int64(_LT) * _LL( rhs )) >> 16 ); return *this; }
    Fixed& operator /= ( const Fixed& rhs ) { _LT = long( (int64(_LT) << 16) / _LL( rhs )); return *this; }
    Fixed& operator %= ( const Fixed& rhs ) { _LT %= _LL( rhs ); return *this; }

    Fixed operator + ( const Fixed& rhs ) const { Fixed ret = *this; ret += rhs; return ret; }
    Fixed operator - ( const Fixed& rhs ) const { Fixed ret = *this; ret -= rhs; return ret; }
    Fixed operator * ( const Fixed& rhs ) const { Fixed ret = *this; ret *= rhs; return ret; }
    Fixed operator / ( const Fixed& rhs ) const { Fixed ret = *this; ret /= rhs; return ret; }
    Fixed operator % ( const Fixed& rhs ) const { Fixed ret = *this; ret %= rhs; return ret; }

    Fixed operator + ( const short rhs ) const { Fixed ret = *this; ret += rhs; return ret; }
    Fixed operator - ( const short rhs ) const { Fixed ret = *this; ret -= rhs; return ret; }
    Fixed operator * ( const short rhs ) const { Fixed ret = *this; ret *= rhs; return ret; }
    Fixed operator / ( const short rhs ) const { Fixed ret = *this; ret /= rhs; return ret; }
    Fixed operator % ( const short rhs ) const { Fixed ret = *this; ret %= rhs; return ret; }

    #undef _F1
    #undef _LL
    #undef _LT
};

#endif//ndef __Fixed_hpp_incl__
#endif//def __cplusplus
// EOF