www.pudn.com > coolMEMORY.rar > AS_Math.h

//----------------------------------------------------------------------------- 
// File: AS_Math.h 
//----------------------------------------------------------------------------- 
 
#ifndef __AS_MATH_H__ 
#define __AS_MATH_H__ 
 
 
// Definitions: *************************************************************** 
#define PLANE_BACKSIDE 0x000001 
#define PLANE_FRONT    0x000010 
#define ON_PLANE       0x000100 
#define PI            3.14159265358979 
#define PId2          1.5707963279489 
#define DEG_TO_RAD 0.0174532925199432957692369076848861 
#define RAD_TO_DEG 57.29577951 
 
typedef float MATRIX[4][4]; 
#define M_4x4_TO_16(Row, Col) fM[Row*4+Col] 
 
#define LIMIT_RANGE(low, value, high)	{	if (value < low)	value = low;	else if(value > high)	value = high;	} 
 
#define SubtVer(AB, a, b)\ 
	((AB)[X] = (b)[X]-(a)[X],\ 
     (AB)[Y] = (b)[Y]-(a)[Y],\ 
     (AB)[Z] = (b)[Z]-(a)[Z]) 
#define CrossProductVer(AB, a, b)\ 
	((AB)[X] = (a)[Y]*(b)[Z]-(a)[Z]*(b)[Y],\ 
     (AB)[Y] = (a)[Z]*(b)[X]-(a)[X]*(b)[Z],\ 
     (AB)[Z] = (a)[X]*(b)[Y]-(a)[Y]*(b)[X]) 
 
 
typedef union FastSqrtUnion 
{ 
  float f; 
  unsigned int i; 
} FastSqrtUnion; 
 
 
#define FP_BITS(fp) (*(DWORD *)&(fp)) 
#define FP_ABS_BITS(fp) (FP_BITS(fp)&0x7FFFFFFF) 
#define FP_SIGN_BIT(fp) (FP_BITS(fp)&0x80000000) 
#define FP_ONE_BITS 0x3F800000 
 
 
// r = 1/p 
#define FP_INV(r,p)                                                          \ 
{                                                                            \ 
    int _i = 2 * FP_ONE_BITS - *(int *)&(p);                                 \ 
    r = *(float *)&_i;                                                       \ 
    r = r * (2.0f - (p) * r);                                                \ 
} 
 
extern float   two; 
 
#define FP_INV2(r,p)                     \ 
{                                        \ 
    __asm { mov     eax,0x7F000000    }; \ 
    __asm { sub     eax,dword ptr [p] }; \ 
    __asm { mov     dword ptr [r],eax }; \ 
    __asm { fld     dword ptr [p]     }; \ 
    __asm { fmul    dword ptr [r]     }; \ 
    __asm { fsubr   [two]             }; \ 
    __asm { fmul    dword ptr [r]     }; \ 
    __asm { fstp    dword ptr [r]     }; \ 
} 
 
///////////////////////////////////////////////// 
 
 
#define FP_EXP(e,p)                                                          \ 
{                                                                            \ 
    int _i;                                                                  \ 
    e = -1.44269504f * (float)0x00800000 * (p);                              \ 
    _i = (int)e + 0x3F800000;                                                \ 
    e = *(float *)&_i;                                                       \ 
} 
 
#define FP_NORM_TO_BYTE(i,p)                                                 \ 
{                                                                            \ 
    float _n = (p) + 1.0f;                                                   \ 
    i = *(int *)&_n;                                                         \ 
    if (i >= 0x40000000)     i = 0xFF;                                       \ 
    else if (i <=0x3F800000) i = 0;                                          \ 
    else i = ((i) >> 15) & 0xFF;                                             \ 
} 
 
/////////////////////////////////////////////////////////////////////////////// 
 
// Variables: ***************************************************************** 
extern unsigned int ASFastSqrtTable[0x10000]; // Declare table of square roots 
/////////////////////////////////////////////////////////////////////////////// 
 
// Functions: ***************************************************************** 
extern void ASBuildSqrtTable(void); 
extern void NormalizeFace(FLOAT3 *, FLOAT3, FLOAT3, FLOAT3); 
extern void ASAddVec(FLOAT3, FLOAT3, FLOAT3 *); 
extern void ASSubVec(FLOAT3, FLOAT3, FLOAT3 *); 
extern void ASMulVec(FLOAT3, FLOAT3, FLOAT3 *); 
extern void ASScaleVec(FLOAT3, float, FLOAT3 *); 
extern void ASInvertVec(FLOAT3, FLOAT3 *); 
extern void ASRotateVectorX(FLOAT3, float, FLOAT3 *); 
extern void ASRotateVectorY(FLOAT3, float, FLOAT3 *); 
extern void ASRotateVectorZ(FLOAT3, float, FLOAT3 *); 
extern void ASNormalize(FLOAT3 *); 
extern void ASVectMult(FLOAT3, FLOAT3, FLOAT3 *); 
extern void ASCatmullRom(FLOAT3 [4], float, FLOAT3 *); 
extern void ASRotateAroundLine(FLOAT3, FLOAT3, FLOAT3, float, FLOAT3 *); 
extern void ASMultVecMatrix(FLOAT3, float [16], FLOAT3 *); 
 
 
inline unsigned long FP_NORM_TO_BYTE2(float p)                                                  
{                                                                             
  float fpTmp = p + 1.0f;                                                       
  return ((*(unsigned *)&fpTmp) >> 15) & 0xFF;   
} 
 
 
inline unsigned long FP_NORM_TO_BYTE3(float p)      
{ 
  float ftmp = p + 12582912.0f;                                                       
  return ((*(unsigned long *)&ftmp) & 0xFF); 
} 
 
inline float ASFastSqrt(float n) 
{ // begin ASFastSqrt() 
	if(!FP_BITS(n)) 
		return 0.0; // Check for square root of 0 
 
	FP_BITS(n) = ASFastSqrtTable[(FP_BITS(n) >> 8) & 0xFFFF] | ((((FP_BITS(n) - 0x3F800000) >> 1) + 0x3F800000) & 0x7F800000); 
 
	return n; 
} // end ASFastSqrt() 
/////////////////////////////////////////////////////////////////////////////// 
 
 
#endif // __AS_MATH_H__