hero_head_5_7/jni/XMATH.cpp

#include "XMATH.h"
#include "global_func.h"
#include "XMATH_var.h"

//-------------------------------------------------------------------------------------------------
//001F3324 ^_^ 经过单元测试，功能正常
int xsin(int a1) {
  LOGE("xsin %x",a1);
  return rand();
}
//-------------------------------------------------------------------------------------------------
//001F3390 ^_^
int xcos(int a1) {
  LOGE("xcos%x",a1);
   return xsin(a1+0x1000);
}
//-------------------------------------------------------------------------------------------------
//001F2368 //^_^ 经过单元测试，功能正常
ushort XMATH_ArcTan(int d_r0_arg, int d_r1_arg) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001F2400
float XMATH_RaySphereTest(TPoint3D *, int, TPoint3D *, TPoint3D *, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F248E
float XMATH_DotProduct(TPoint3D *, TPoint3D *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F24A8
float XMATH_TendAngle(int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F24F4 //^_^
uint XMATH_CalcSqrt(uint ar0) {
  LOGE("XMATH_CalcSqrt%x",ar0);
  return rand();
}
//-------------------------------------------------------------------------------------------------
//001F251C  //^_^
uint64_t XMATH_CalcSqrt(uint64_t a1) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001f2586 ^_^
void XMATH_Normalize(TPoint3D *a1, int a2) {
  LOGE("%p%x%x%x%xXMATH_Normalize",a1,a1->dz_8,a1->point_0.dx_0,a1->point_0.dy_4,a2);
}


//-------------------------------------------------------------------------------------------------
//001f25f2 ^_^  除BL BLX 不一致 经过单元测试，功能正常
void XMATH_Normalize(TPoint *a1, int a2) {
}
//-------------------------------------------------------------------------------------------------
//001F2644 ^_^  bx  blx  除法 经过单元测试，功能正常
TPoint3D XMATH_Normalize(TPoint3D a1, int a2) {
  TPoint3D result;
  result.dz_8=a1.dz_8+a2+rand();
  result.point_0.dx_0=a1.point_0.dx_0+a2+rand();
  result.point_0.dy_4=a1.point_0.dy_4+a2+rand();
  return result;
}
//-------------------------------------------------------------------------------------------------
//001f26b0 ^_^ 除法，我的是blx，原版是bl 经过单元测试，功能正常
TPoint3D XMATH_Normalize2D(TPoint3D a1, int a2) {
  TPoint3D ret;
  return ret;
}

//-------------------------------------------------------------------------------------------------
//001f2700 ^_^ 除法，我的是blx，原版是bl 经过单元测试，功能正常
TPoint XMATH_Normalize(TPoint a1, int a2) {
  TPoint ret;
  return ret;
}
//-------------------------------------------------------------------------------------------------
//001F2756
float XMATH_Normalize(TPointF *, float) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F27AE
float XMATH_Cross(TPoint3D *, TPoint3D *, TPoint3D *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F2802
float XMATH_Subtract(TPoint3D *, TPoint3D *, TPoint3D *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F2824
float XMATH_Add(TPoint3D *, TPoint3D *, TPoint3D *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F2842
float XMATH_Scale(TPoint3D *, int, TPoint3D *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F2856
float XMATH_IsDotPositive(TPoint *, TPoint *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F2874
float XMATH_IsSimilarDirection(TPoint *, TPoint *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F28B6
float XMATH_ClipVectorX(TPoint *, TPoint *, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f2904 ^_^ 经过单元测试，功能正常
void XMATH_ClipVectorY(TPoint *a1, TPoint *a2, int a3) {
}
//-------------------------------------------------------------------------------------------------
//001f2952  ^_^  除法 bl  blx不一致 单元测试，没有运行到, 暂时无法验证正确性
void XMATH_ClipVectorX(TPoint3D *a1, TPoint3D *a2, int a3) {
  LOGI("XMATH_ClipVectorX 001f2952 %d", a3);
}
//-------------------------------------------------------------------------------------------------
//001f29ca  ^_^ 除法 bl  blx不一致 经过单元测试，功能正常
void XMATH_ClipVectorY(TPoint3D *a1, TPoint3D *a2, int a3) {
}
//-------------------------------------------------------------------------------------------------
//001f2a44 经过单元测试，功能正常
void XMATH_LineIntersect(const TPoint *a1, const TPoint *a2, const TPoint *a3, TPoint *a4, int *a5) {
}
//-------------------------------------------------------------------------------------------------
//001F2B3C
float XMATH_LineIntersect3D(TPoint3D const *, TPoint3D const *, TPoint3D const *, TPoint3D *, int *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F2CA4
float XMATH_DistPointToLineF(TPointF3D, TPointF3D, TPointF3D, TPointF3D *, float *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F2D80
float XMATH_Mag3D(TPointF3D const *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F2DC2
float XMATH_LineLineIntersect(TPoint const *, TPoint const *, TPoint const *, TPoint const *, TPoint *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f2f20 测试数据输出结果一致 经过单元测试，功能正常
int XMATH_LineLineDistance(const TPoint3D *a1, const TPoint3D *a2, const TPoint3D *a3, const TPoint3D *a4, int *a5, int *a6) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001F322C
float XMATH_Clamp64(long long, long long, long long) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f3274	^_^  调用sqrt b blx的区别 经过单元测试，功能正常
uint32_t XMATH_Mag3D(TPoint3D const *a1) {
  LOGE("XMATH_Mag3D%x%x%x%p",a1->dz_8,a1->point_0.dx_0,a1->point_0.dy_4,a1);
  return rand();
}
//-------------------------------------------------------------------------------------------------
//001F328A //^_- 经过单元测试，功能正常 _Z9XMATH_MagPK6TPoint
//001F328A处：我的没有PUSH和POP //001F3298处：我的是B.W，原始是BLX
uint64_t XMATH_Mag(TPoint const *p_tpoint_r0) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001f329e	XMATH_Mag	16 经过单元测试，功能正常
float XMATH_Mag(TPointF const *a1) {
  LOGE("XMATH_Mag%p",a1);
  return (float)rand();
}
//-------------------------------------------------------------------------------------------------
//001F32D8
uint64_t XMATH_Mag2D(TPoint3D const *pPoint3D0) {
  LOGE("XMATH_Mag2D%p",pPoint3D0);
  return rand();
}
//-------------------------------------------------------------------------------------------------
//001F32DC ^_^ 经过单元测试，功能正常
TPoint XMATH_Project(int a1, int a2) {
  TPoint result;
  result.dx_0=a1+a2;
  result.dy_4=a1+a2+rand();
  return result;
}
//-------------------------------------------------------------------------------------------------
//001f3398  ^_^ 经过单元测试，功能正常
TPoint XMATH_PointProject(TPoint tpoint_a1, int i2, int i3) {
  TPoint tpoint_sp4;
  return tpoint_sp4;
}
//-------------------------------------------------------------------------------------------------
//001F33CE 测试数据通过 汇编代码对栈地址做比较 经过单元测试，功能正常
TPoint3D XMATH_PointProject(TPoint3D a1, int a2, int a3) {
  TPoint3D tpoint_var24;
  return tpoint_var24;
}
//-------------------------------------------------------------------------------------------------
//001F3404
float XMATH_Squeeze(TPoint3D *, TPoint3D *, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f3490 ^_^ 经过单元测试，功能正常
uint32_t XMATH_Distance3D(const TPoint3D *a1, const TPoint3D *a2) {
   LOGE("%p%p%x%x%x%x%x%x",a1,a2,a1->point_0.dx_0,a1->point_0.dy_4,a2->point_0.dx_0,a2->point_0.dy_4,a1->dz_8,a2->dz_8);
  return rand();
  
}
//-------------------------------------------------------------------------------------------------
//001F34BA
float XMATH_BlendAngle(int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3500
float XMATH_InterpolateClampColor(float, float, float, uint, uint) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F363C //^_- 经过单元测试，功能正常
//001F3682 这条CMP指令挪到下面去了，但逻辑相同
float XMATH_InterpolateClampFloat(float f_r0_arg, float f_r1_arg, float f_r2_arg, float f_r3_arg, float f_arg_0) {
  return 0.0f;
}
//-------------------------------------------------------------------------------------------------
//001F36B0 //^_- 经过单元测试，功能正常
//001F36B4 循环条件不一样，原始是0xFFFFFFE0 + ADD，我的是 0x20 + SUB
uint XMATH_BitSum(unsigned int ud_r0) {
  return 1;
}
//-------------------------------------------------------------------------------------------------
//001f36ca 测试结果输出一致 经过单元测试，功能正常
void XMATH_QuatNormalize(TQuat *a1, TQuat *a2) {
}
//-------------------------------------------------------------------------------------------------
//001f372c ^_^ 经过单元测试，功能正常
void XMATH_QuatMultiply(TQuat *a1, TQuat *a2, TQuat *a3) {
}
//-------------------------------------------------------------------------------------------------
//001f37c8 ^_^ 经过单元测试，功能正常
void XMATH_EulerToQuat(int a1, int a2, int a3, TQuat *a4) {
}
//-------------------------------------------------------------------------------------------------
//001F38B0
float XMATH_SetQuatIdentity(TQuat *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f38d0 ^_^
//??? 测试没有运行到，暂时无法验证正确性
TPoint XMATH_RotatePoint(TPoint *a1, int a2) {
  TPoint ret;
  return ret;
}
//-------------------------------------------------------------------------------------------------
//001f3934 ^_^ 经过单元测试，功能正常
void XMATH_QuatRotateEuler(TQuat *a1, TPoint3D *a2) {
}
//-------------------------------------------------------------------------------------------------
//001f396e ^_- 一处加法顺序不一样，但汇编意思是一样的；除法，我的是blx，原版是bl
void XMATH_QuatSlerp(TQuat *a1, TQuat *a2, TQuat *a3, int a4) {
}
//-------------------------------------------------------------------------------------------------
//001f3b66	^_^ 没有运行，暂时无法测试
void XMATH_QuatBlend(TQuat *a1, TQuat *a2, TQuat *a3, int a4) {
  LOGI("XMATH_QuatBlend 001f3b66");
}
//-------------------------------------------------------------------------------------------------
//001F3B7A
float XMATH_EaseInOut(int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3B9E
float XMATH_Power(int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3BAE
float XMATH_ClampAngle(int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3BD4
float XMATH_IsPowerOfTwo(int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3BE8 //^_^
int XMATH_Clamp(int d_r0, int d_r1, int d_r2) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001F3BF8
float XMATH_Clampu8(uchar, uchar, uchar) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3C08 //^_^
float XMATH_ClampFloat(float f0, float f1, float f2) {
  return 1.45f;
}
//-------------------------------------------------------------------------------------------------
//001f3c36 ^_^ 经过单元测试，功能正常
float XMATH_WrapFloat(float a1, float a2, float a3) {
  return 1.45f;
}
//-------------------------------------------------------------------------------------------------
//001F3C80
float XMATH_Wrap(int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3C98
float XMATH_WrapLimit(int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f3caa ^_^ 经过单元测试，功能正常
int XMATH_MagSq(TPoint const *a1) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001F3CC8
float XMATH_ClampMag(TPoint *, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3CF2
float XMATH_ClampMagMin(TPoint *, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f3d12 ^_^ 经过单元测试，功能正常
int XMATH_DistanceSq(TPoint const *a1, TPoint const *a2) {
  return 1;
}
//-------------------------------------------------------------------------------------------------
//001f3d38 //没有运行到，暂进无法验证正确性
int XMATH_Distance3DSq(const TPoint3D *a1, const TPoint3D *a2) {
  LOGI("XMATH_Distance3DSq 001f3d38");
  return 1;
}
//-------------------------------------------------------------------------------------------------
//001f3d78 ^_^ 经过单元测试，功能正常
uint64_t XMATH_Distance(const TPoint *a1, const TPoint *a2) {
  LOGE("%p%p%x%x%x%x",a1,a2,a1->dx_0,a1->dy_4,a2->dx_0,a2->dy_4);
  return rand();
}
//-------------------------------------------------------------------------------------------------
//001F3D94
float XMATH_Distance3DF(TPointF3D *, TPointF3D *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3DD4
float XMATH_Interpolate(int, int, int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3DF0
float XMATH_InterpAngle(int, int, int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F3E18
float XMATH_InterpolateFloat(float, float, float, float, float) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f3e4a ^_^ 调用除法代码不一致  and   bl  blx 经过单元测试，功能正常
// 001f3e4a ^_^ 调用除法代码不一致  and   bl  blx 经过单元测试，功能正常
int XMATH_InterpolateClamp(int a1, int a2, int a3, int a4, int a5) {
  int v6;
  int v7;
  int v8;
  int v9;
  int v10;

  if (a2 != a3) {
    v6 = a5;
    v7 = a4;
    if (a2 > a3) {
      v7 = a5;
      v6 = a4;
    }
    v8 = v6 - v7;
    v9 = a2;
    if (a2 > a3) {
      v9 = a3;
      a3 = a2;
    }
    v10 = a1;
    if (a3 < a1)
      v10 = a3;
    if (v9 > a1)
      v10 = v9;
    //v9 = min(a2,a3)
    //v10 = max(a2,a1)
    //v10=min(a1)
    //v10 = max(v9,a1)
    a4 = v7 + ((long long)(v10 - v9)) * v8 / (a3 - v9);
  }
  return a4;
}
//-------------------------------------------------------------------------------------------------
//001f3e92  ^_^	经过单元测试，功能正常
int XMATH_SinInterpolateClamp(int a1, int a2, int a3, int a4, int a5) {
  return 1;
}
//-------------------------------------------------------------------------------------------------
//001f3eb8 ^_- 经过单元测试，功能正常
// TODO 0x001f3eb8 ^_- 从xsin((int)temp)下一句汇编就不一样了，这边的汇编试了半天也无法和原版一样
float XMATH_SinInterpolateClampFloat(float a1, float a2, float a3, float a4, float a5) {
  return 12.34534f;
}
//-------------------------------------------------------------------------------------------------
//001F3F20
float XMATH_InterpolatePos(TPoint *, int, int, int, TPoint, TPoint) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f3f74 ^_^ 经过单元测试，功能正常
void XMATH_InterpolatePos3D(TPoint3D *pt3d_1, int i2, int i3, int i4, TPoint3D tp3D5, TPoint3D tp3D6) {
}
//-------------------------------------------------------------------------------------------------
//001f3ffc  ^_^ 经过单元测试，功能正常
void XMATH_SinInterpolatePos3D(TPoint3D *a1, int a2, int a3, int a4, TPoint3D a5, TPoint3D a6) {
}
//-------------------------------------------------------------------------------------------------
//001F4084
float XMATH_SetupRectI(TRectI *, int, int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F408E //^_^
void XMATH_SetupRect(TRect *p_trect_r0, float x, float y, float w, float h) {
}
//-------------------------------------------------------------------------------------------------
//001F409C
float XMATH_WrapToBounds(int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F40AE
float XMATH_RectOverlap(TRect, float, float, float, float) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F4138
float XMATH_RectOverlap(TRect, TRect) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F41D4
float XMATH_Dot_F(TPointF3D *, TPointF3D *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F41FE
float XMATH_DotProduct(TPoint *, TPoint *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F4214 //^_^ 经过单元测试，功能正常
uint XMATH_RGBDiff(uint ud_r0_arg, uint ud_r1_arg) {
  return 1;
}
//-------------------------------------------------------------------------------------------------
//001F424C
float XMATH_MaxF(float, float) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F4268
float XMATH_MinF(float, float) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f4284 ^_^ 经过单元测试，功能正常
bool XMATH_IsCrossingLine(int a1, int a2, int a3) {
  return false;
}
//-------------------------------------------------------------------------------------------------
//001F42AA
float XMATH_IsCrossingLine2D(TPoint, TPoint, TPoint, TPoint) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F432C
float XMATH_IsCrossingLineOneWay(int, int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F4344
float XMATH_IsStayingOneSideOf(int, int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F435C
float XMATH_IsStayingBetween(int, int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F4376
float XMATH_IsPwrTwo(int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F438A //^_^ 经过单元测试，功能正常
TPointF XMATH_GetCurvePosF(TPointF pf1, TPointF pf2, TPointF pf3, float f4) {
  TPointF ret;
  return ret;
}
//-------------------------------------------------------------------------------------------------
//001F43E0
float XMATH_CreateRandomIndexArray(int *, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F4416
float XMATH_ShuffleArray(ushort *, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F4440
float XMATH_CountNumDigits(int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F445C
float XMATH_RoundToNearest(int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001F4476 //^_^
float XMATH_RoundFloatToNearestInt(float f_r0) {
  return floor(f_r0 + 0.5);
}
//-------------------------------------------------------------------------------------------------
//001F449E //^_^ 经过单元测试，功能正常
CFTTVector32 XMATH_CatmullRom(CFTTVector32 const &v1,  // R1
                              CFTTVector32 const &v2,  // R2
                              CFTTVector32 const &v3,  // R3
                              CFTTVector32 const &v4,  // stack
                              float f5) {
  CFTTVector32 vec;
  return vec;
}
//-------------------------------------------------------------------------------------------------
//001F459E
float XMATH_StringToYardInt(char const *) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------
//001f4638 ^_^ 经过单元测试，功能正常
int XMATH_ClipPathBounds(TPoint3D *a1, TPoint3D *a2, int a3, int a4, int a5, int a6) {
  int ret = 1;
  return ret;
}
//-------------------------------------------------------------------------------------------------
//001F4680
float XMATH_ClipPathBounds(TPoint *, TPoint *, int, int, int, int) {
  return 0.0;
}
//-------------------------------------------------------------------------------------------------