Fxp.h

Go to the documentation of this file.

/***************************************************************************
           Fxp.h  - SDL-based fixed point macros, types, and classes.
                        -------------------
    begin                : Mon Mar 3 2003
    copyright            : (C) 2003 by Tyler Montbriand
    email                : tsm@accesscomm.ca
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef __FXP_H__
#define __FXP_H__

#include <SDL/SDL_types.h>
/* Still needed for vector magnitudes, not much else */
#include <math.h>

#include <SDL/begin_code.h>

#ifdef __cplusplus
extern "C" {
#endif


#ifdef __GNUC__

#undef Sint64
#define Sint64 long long

#undef Uint64
#define Uint64 unsigned long long
#endif/*__GNUC__*/


typedef float FxpFloat;


#define SFXP_BITS       10      /*10 bits precision, ~1/1000th accuracy */

#define SFXP_SCALAR     (1<<SFXP_BITS)

typedef Sint32          Sfxp;

#define TO_SFXP(x)      (((Sint32)(x))<<SFXP_BITS)

#define FROM_SFXP(x)    ((Sint32)((x+((SFXP_SCALAR>>1)))>>SFXP_BITS))

#define F_TO_SFXP(x)    ((Sfxp)((x)*SFXP_SCALAR))

#define SFXP_TO_F(x)    ( ((FxpFloat)(x)) / ((FxpFloat)SFXP_SCALAR) )

#define MUL_SFXP(x,y)  FROM_SFXP(((Sint64)(x))*((Sint64)(y)))

#define DIV_SFXP(x,y)  ((Sfxp)((TO_SFXP((Sint64)(x)))/y))



#define AFXP_BITSIZE  (sizeof(Afxp)*8)

#define AFXP_MAX      (1<<AFXP_BITSIZE)

#define AFXP_BITS       8       /*16-bit angles, 8-bit decimals */

typedef Uint16          Afxp;   /* Angles are a 16-bit type     */
#define FXP_PI          3.14159f

#define DEG_TO_AFXP(x)  ((Afxp)((x)*( ((double)AFXP_MAX) /360.)))

#define RAD_TO_AFXP(x)  DEG_TO_AFXP((x)*(180./3.14159))

#define AFXP_TO_DEG(x)  ((x)*(360./AFXP_MAX))



DECLSPEC void SDLCALL FXP_Init();
DECLSPEC Sfxp SDLCALL FXP_Sin(Afxp a);
DECLSPEC Afxp SDLCALL FXP_Asin(Sfxp val);
DECLSPEC Sfxp SDLCALL FXP_Cos(Afxp a);
DECLSPEC Afxp SDLCALL FXP_Acos(Sfxp val);
DECLSPEC Sfxp SDLCALL FXP_Tan(Afxp a);
DECLSPEC Afxp SDLCALL FXP_Atan(Sfxp val);
DECLSPEC Afxp SDLCALL FXP_Traj(Sfxp y, Sfxp x);

#if defined(__cplusplus)

class DECLSPEC SfxpCoord
{
public:
  inline SfxpCoord(FxpFloat xin, FxpFloat yin)
  { SetFloat(xin,yin);  }
  
  inline SfxpCoord(int xin=0,int yin=0)
  { SetInt(xin,yin);  }

  inline bool operator ==(SfxpCoord &coord)
  { return((x=coord.x)&&(y==coord.y));  }

  inline bool operator !=(SfxpCoord &coord)
  { return(!((*this)==coord));  }

  inline SfxpCoord operator +(SfxpCoord coord)
  {
    SfxpCoord ncoord;

    ncoord.SetFxp(x+coord.x,y+coord.y);
    return(ncoord);
  }
  
  inline SfxpCoord operator -(SfxpCoord coord)
  {
    SfxpCoord ncoord;

    ncoord.SetFxp(x-coord.x,y-coord.y);
    return(ncoord);
  }

  inline SfxpCoord operator +=(SfxpCoord coord)
  {
    x+=coord.x;
    y+=coord.y;
    return(*this);
  }

  inline SfxpCoord FxpScalar(Sfxp val)
  {
    x=MUL_SFXP(x,val);
    y=MUL_SFXP(y,val);
    return(*this);
  }

  inline Afxp Trajectory()
  { return(FXP_Traj(y,x)); }

  inline SfxpCoord IntScalar(int val)
  {
    x*=val;
    y*=val;
    return(*this);
  }

  inline bool MajorDigitsEqual(SfxpCoord coord) const
  {
    if((X()==coord.X())&&(Y()==coord.Y()))  return(true);
    else                                    return(false);
  }

  inline int X() const
  { return(FROM_SFXP(x)); }

  inline int Y() const
  { return(FROM_SFXP(y)); }

  inline int Xfxp() const
  { return(x);  }

  inline int Yfxp() const
  { return(y);  }

  inline FxpFloat Xfloat()
  { return((FxpFloat)x/(FxpFloat)SFXP_SCALAR);  }

  inline FxpFloat Yfloat()
  { return((FxpFloat)y/(FxpFloat)SFXP_SCALAR);  }

  inline SfxpCoord SetFloat(FxpFloat xin, FxpFloat yin)
  {
    Sfxp xsf,ysf;

    xsf=(Sfxp)(xin*(FxpFloat)SFXP_SCALAR);
    ysf=(Sfxp)(yin*(FxpFloat)SFXP_SCALAR);
    SetFxp(xsf,ysf);

    return(*this);
  }

  inline SfxpCoord SetFxp(Sfxp xin, Sfxp yin)
  {
    x=xin;
    y=yin;
    return(*this);
  }

  inline SfxpCoord SetInt(Sint32 xin, Sint32 yin)
  {
    x=TO_SFXP(xin);
    y=TO_SFXP(yin);
    return(*this);
  }  

  inline int Nonzero()
  { return(x|y);  }

  inline void Vector(Sfxp magnitude, Afxp angle)
  {
    x=MUL_SFXP(FXP_Cos(angle),magnitude);
    y=MUL_SFXP(FXP_Sin(angle),magnitude);
  }

  Sfxp Magnitude()
  {
    if(Nonzero())
    {
      FxpFloat x2=SFXP_TO_F(x)*SFXP_TO_F(x);
      FxpFloat y2=SFXP_TO_F(y)*SFXP_TO_F(y);

      return(F_TO_SFXP(sqrt(x2+y2)));
    }
    else
      return(0);
  }

private:
  Sfxp x,y;
};

class DECLSPEC Angle
{
public:
  inline Angle(Afxp ain)
  { angle=ain;            }

  inline Angle(int degrees)
  { SetDegrees(degrees);  }

  inline Angle(FxpFloat radians)
  { SetRadians(radians);  }

  inline int Degrees() const
  { return((int)AFXP_TO_DEG(angle));  }

  inline FxpFloat Radians() const
  { return((FxpFloat)((FXP_PI/180.)*AFXP_TO_DEG(angle))); }

  inline Afxp Fxp() const
  { return(angle);  }

  inline Angle operator+=(Afxp ain)
  {
    angle+=ain;
    return(*this);
  }

  inline Angle operator-=(Afxp ain)
  {
    angle-=ain;
    return(*this);
  }

  inline Angle operator+(const Angle &ain)
  { return(Angle(angle+ain.Fxp())); }

  inline Angle SetDegrees(int degrees)
  {
    angle=DEG_TO_AFXP(degrees);
    return(*this);
  }
  inline Angle SetRadians(double radians)
  {
    angle=RAD_TO_AFXP(radians);
    return(*this);
  }

  inline Sfxp Sin() const
  { return(FXP_Sin(angle)); }

  inline Sfxp Cos() const
  { return(FXP_Cos(angle)); }

  inline Sfxp Tan() const
  { return(FXP_Tan(angle)); }

private:
  Afxp angle;
};
#endif/*__cplusplus*/


#ifdef __cplusplus
}
#endif

#include <SDL/close_code.h>

#endif/*__FXP_H__*/

---