imath.cpp

liu7788414

/*

int GetYOrient(const Vector4s *Src,const Vector4s *Dest)
{
  return Atan2i(Dest->z - Src->z, Dest->x - Src->x);
}

int GetXOrient(const Vector4s *Src,const Vector4s *Dest)
{
    Vector4s distVector = *Dest - *Src;
    int nXZLength= FSqrt(distVector.x * distVector.x + distVector.z * distVector.z);
    return Atan2i(nXZLength, distVector.y);
}*/

int AngleDiff(int SrcAngle, int TargetAngle)
{
  int Delta = (TargetAngle - SrcAngle) & ANGLEMASK;
  if (Delta > (ANGLE2PI/2))
    Delta -= ANGLE2PI;
  return Delta;
}

// return B with (1 << B) == A
int Log2(int a)
{
  int b = 0;
  while ((1<<b) <= a)
    b++;
  return b;
}


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
int GetFovFromXAngle(int in_nXAngle)
{
    in_nXAngle>>=1;
    SYS_ASSERT(0 < in_nXAngle && in_nXAngle < PGL_PI);
    // tan
    int nTan = (Sinus(in_nXAngle)<<COS_SIN_SHIFT)/Cosinus(in_nXAngle);
    return ((RENDER_WIDTH>>1)<<COS_SIN_SHIFT)/nTan;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
int GetFovFromYAngle(int in_nYAngle)
{
    in_nYAngle>>=1;
    SYS_ASSERT(0 < in_nYAngle && in_nYAngle < PGL_PI);
    // tan
    int nTan = (Sinus(in_nYAngle)<<COS_SIN_SHIFT)/Cosinus(in_nYAngle);
    return ((RENDER_HEIGHT>>1)<<COS_SIN_SHIFT)/nTan;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
int GetXAngleFromFov(int in_nFov)
{
    return Atan2i(in_nFov, RENDER_WIDTH>>1)<<1;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
int GetYAngleFromFov(int in_nFov)
{
    return Atan2i(in_nFov, RENDER_HEIGHT>>1)<<1;
}






#if CHECK_MATH

#include <limits.h>
#include <assert.h>

volatile static bool _disable = false;

// ---------------------------------------------------------------------------
//	Used bu debug macros CHK_MULT and CHK_LIMITS; see Defines.h
// ---------------------------------------------------------------------------
void _Check_Int_Limit(double x)
{

	if(!_disable)
	{
		SYS_ASSERT(x <= double(INT_MAX) && x >= double(INT_MIN));
	}

}


void _Check_Short_Limit(double x)
{
	if(!_disable)
	{
		SYS_ASSERT(x <= double(SHRT_MAX) && x >= double(SHRT_MIN));
	}
}





void _Check_Precision(double fResult, int nResult, double fTolerancePercentage)
{
    double fError = fResult - nResult;
    if (fError < 0) fError = -fError;
    double fTolerance = fTolerancePercentage*fResult/100;
    if (fTolerance < 0) fTolerance = -fTolerance;
    SYS_ASSERT(int(fError) <= int(fTolerance)); // always tolerate decimal error
}

#endif //#if CHECK_MATH









int fMul( int a, int b ) 
{
    if ( a >= 0 )
        return ( (a >> 12) * b ) + ( ((a & 0xfff) * b) >> 12 );
    else
        return  -( ((-a) >> 12) * b + ((((-a) & 0xfff) * b) >> 12) );
}

int fDiv( int a, int b ) 
{
    int         t, s;

    s = 1;
    if ( a < 0 ) {
        a = -a;
        s = -s;
    }
    if ( b < 0 ) {
        b = -b;
        s = -s;
    }

    if ( ( (b) >> 6 ) == 0 ) {
        t = FP_MAX_VALUE;
    } else {
        t = ( (a) << 6 ) / ( (b) >> 6 );
    }

    t *= s;

    return t;
}


int convertInto2048(int x, int y, int angle)
{
    if(x==0&&y==0)
    	angle = 0;
    if(x<=0&&y>=0)
    	angle = 1024 - angle;
    if(x<=0&&y<=0)
    	angle = 1024 + angle;
    if(x>=0&&y<=0)
    	angle = 2048 - angle;
    return angle;
}



int sqrt(int value)
{
	int  a, b;

    if ( value == 0 )
      return 0;

    a = value / 2;
    do
    {
      if(a==0)
      	return 1;
      b = ( value / a - a ) / 2;
      a = a + b;
    } while ( ( b > 1 ) || ( b < -1 ) );

    return a;
}

int getSign(int value)
{
    int b = 0;
    if(value<0)
    	b = -1;
    if(value>0)
    	b = 1;
    return b;
}

int _rand(int min, int max)
{
	
	int random=rand();
	if( random < 0 )
		random = -random;
	return ((random%(max - min + 1)) + min);
}

int getRandomNumber(int range ) 
{
	return _rand(0, range);
}

int distanceP2P(int x1, int y1, int x2, int y2)
{
  	int dx = x2-x1;
	int dx2 = dx*dx;
  	int dy = y2-y1;
	int dy2 = dy*dy;
	int d2 = dx2+dy2;
  	int dis;

	if(dx2<0 || dy2<0 || d2<0)
	{
		d2 = (int)((unsigned int)(dx2) >> 2)+(int)((unsigned int)(dy2) >> 2);
		dis = sqrt(d2)<<1;
	}
	else
		dis = sqrt(d2);
  	return dis;
}

int distanceP2P(int x1, int y1, int z1, int x2, int y2, int z2) {
	int dx = x2 - x1;
	int dy = y2 - y1;
	int dz = z2 - z1;
	int dis = sqrt( (long) dx * dx + dy * dy + dz * dz);
	return dis;
}

int distanceP2L(int x1, int y1, int x2, int y2, int xp, int yp)
{
  	int dis;
	int d2  = distanceP2P(x1,y1,x2,y2);
	if(d2==0){
		dis = distanceP2P(x1,y1,xp,yp);
	}
	else{
  	 	dis = Abs((x2-x1)*(yp-y1)-(y2-y1)*(xp-x1))/d2;
	}
  	return dis;
}