Sfoglia il codice sorgente

UpdateCrowdTextures

DESKTOP-AB9OQPJ\RED-10 3 anni fa
parent
commit
4031714d6b

+ 22 - 0
jni/CAnimLib.cpp

@@ -5,6 +5,28 @@
 #include "TGame.h"
 #include "memctrl.h"
 
+ Anim_462764 dword_462764[21] = {
+    {0x187, 8, 0, 0, 0, 0, 0x187},
+    {0x189, 6, 0, 2, 9, 11, 0x189},
+    {0x18D, 2, 0, 0, 0, 0, 0x18D},
+    {0x186, 2, 0, 0, 0, 0, 0x186},
+    {0x33C, 4, 0, 0, 0, 0, 0x33C},
+    {0x189, 0x06, 0x16, 0x18, 0x22, 0x24, 0x189},
+    {0x555, 3, 0, 3, 5, 7, 0x555},
+    {0x1ED, 8, 0, 0, 0, 0, 0x1ED},
+    {0x7AD, 8, 0, 0, 0, 0, 0x7AD},
+    {0x7B1, 8, 18, 0, 4, 14, 0x7B1},
+    {0x35E, 4, 3, 5, 19, 21, 0x186},
+    {0x35E, 4, 3, 5, 19, 0x15, 0x35E},
+    {0x666, 4, 16, 18, 22, 24, 0x666},
+    {0x7EF, 6, 23, 25, 33, 35, 0x7EF},
+    {0x187, 8, 0, 0, 0, 0, 0x186},
+    {0x189, 6, 0, 0, 0, 0, 0x186},
+    {0x33C, 6, 0, 0, 0, 0, 0x186},
+    {0x18D, 6, 0, 0, 0, 0, 0x186},
+    {0x555, 3, 0, 32, 96, 8, 0x878},
+    {0x558, 3, 0, 32, 96, 8, 0x878},
+    {0x878, 3, 0, 32, 96, 8, 0x878}};
 TPreLoadAnimData CAnimLib::ms_tPreLoadAnimData[13] = {
     {1, 0xE, 0xC, -1},
     {1, 0xE, 9, 2},

+ 10 - 0
jni/CAnimLib.h

@@ -21,6 +21,15 @@
 
 0x7E6C
 */
+struct Anim_462764 {
+  uint filed_0;
+  char filed_4;
+  char filed_5;
+  char filed_6;
+  char filed_7;
+  char filed_8;
+  uint filed_c;
+};
 
 struct TPreLoadAnimData {
   int filed_0;
@@ -66,5 +75,6 @@ public:
 
   static TPreLoadAnimData ms_tPreLoadAnimData[13];
 };
+extern  Anim_462764 dword_462764[21];
 
 #endif  //_CANIMLIB_H_

+ 2 - 1
jni/CCrowdNewShader.cpp

@@ -1,7 +1,7 @@
 #include "CCrowdNewShader.h"
 #include "CFTTMaterialManager.h"
 #include "shader_data/CCrowdNewShader_Setup.h"
-
+CCrowdNewShader CCrowdNewShader::s_tInstance;
 //-------------------------------------------------------------------------------------------------
 //001CF874
 CCrowdNewShader::CCrowdNewShader() : CFTTUberShader(&CCrowdNewShaderSetup_324348) {
@@ -13,6 +13,7 @@ CCrowdNewShader::~CCrowdNewShader() {
 //-------------------------------------------------------------------------------------------------
 //00197126
 void CCrowdNewShader::SetDiffuse(CFTTTexParam aTexParam, int a2) {
+  LOGE("%x%x%x",aTexParam.GetFlag0(),aTexParam.GetFlag4(),a2);
 }
 //-------------------------------------------------------------------------------------------------
 //001A0DF0

+ 4 - 0
jni/CFTTBatchModelManager.cpp

@@ -154,10 +154,12 @@ bool CFTTBatchModelManager::PerformFlushOnFull() {
 //-------------------------------------------------------------------------------------------------
 //0020F450 //^_^
 void CFTTBatchModelManager::End() {
+  LOGE("End%x",this);
 }
 //-------------------------------------------------------------------------------------------------
 //0020F480 //^_^
 void CFTTBatchModelManager::Begin() {
+  LOGE("Begin%x",this);
 }
 //-------------------------------------------------------------------------------------------------
 //0020F4EC //^_-
@@ -176,6 +178,8 @@ void CFTTBatchModelManager::Flush(int i_r1_arg, bool b_r2_arg, bool b_r3_arg) {
 //-------------------------------------------------------------------------------------------------
 //0020F670 //^_^
 void CFTTBatchModelManager::ResetCache(bool b_r1_arg) {
+  LOGE("%x",this);
+LOGE("%x",b_r1_arg);
 }
 //-------------------------------------------------------------------------------------------------
 //0020F68C //^_^

+ 8 - 0
jni/CFTTCamera.cpp

@@ -73,6 +73,7 @@ void CFTTCamera::Shutdown() {
 //-------------------------------------------------------------------------------------------------
 //001FF58C ^_^ 经过单元测试,功能正常
 void CFTTCamera::ApplyCameraSettings() {
+  LOGE("CFTTCamera::ApplyCameraSettings");
 }
 //-------------------------------------------------------------------------------------------------
 //001FF5B4//^_- 经过单元测试,功能正常
@@ -81,6 +82,7 @@ void CFTTCamera::EvaluateMatricesAndFrustum() {
 //-------------------------------------------------------------------------------------------------
 //001FFA3C ^_^ 经过单元测试,功能正常
 void CFTTCamera::SetPosition(CFTTVector32 const &a1) {
+  LOGE("%x%x%x",a1.float_0,a1.float_4,a1.float_8);
 }
 //-------------------------------------------------------------------------------------------------
 //001FFA64 ^_^ 经过单元测试,功能正常
@@ -109,6 +111,10 @@ void CFTTCamera::SetOrientation(CFTTMatrix32 const &a1) {
 //-------------------------------------------------------------------------------------------------
 //001FFB04 ^_^ 经过单元测试,功能正常
 void CFTTCamera::SetDirection(CFTTVector32 const &a1, CFTTVector32 const *a2) {
+   LOGE("%x%x%x",a1.float_0,a1.float_4,a1.float_8);
+   LOGE("%x",a2);
+   LOGE("%x%x%x",a2->float_0,a2->float_4,a2->float_8);
+
 }
 //-------------------------------------------------------------------------------------------------
 //001FFB38 ^_^
@@ -137,6 +143,7 @@ void CFTTCamera::LookAt(CFTTVector32 const &a1, CFTTVector32 const &a2, float a3
 //-------------------------------------------------------------------------------------------------
 //001FFCF8 ^_^ 经过单元测试,功能正常
 void CFTTCamera::SetOrthographic(float a1, float a2, float a3, float a4, float a5, float a6) {
+  LOGE("CFTTCamera::SetOrthographic=%x%x%x%x%x%x",a1,a2,a3,a4,a5,a6);
 }
 //-------------------------------------------------------------------------------------------------
 //001FFDD8 ^_^ 经过单元测试,功能正常
@@ -162,6 +169,7 @@ void CFTTCamera::GetViewport(int &a1, int &a2) {
 //-------------------------------------------------------------------------------------------------
 //001FFF1C ^_^ 经过单元测试,功能正常
 void CFTTCamera::SetViewport(int a1, int a2, float a3) {
+  LOGE("%x%x%X",a1,a2,a3);
 }
 //-------------------------------------------------------------------------------------------------
 //001FFF88 ^_^

+ 2 - 1
jni/CFTTColour.cpp

@@ -40,7 +40,8 @@ int XSubCol(unsigned int a1, unsigned int a2) {
 //-------------------------------------------------------------------------------------------------
 //00191528 //^_- 已测试,结果相同
 uint XMixCol(uint ud_r0_arg, uint ud_r1_arg, float f_r2_arg) {
-  return 0;
+  LOGE("%x%x%x",ud_r0_arg,ud_r1_arg,f_r2_arg);
+  return rand();
 }
 //-------------------------------------------------------------------------------------------------
 //00191620

+ 2 - 0
jni/CFTTMaterialManager.cpp

@@ -89,6 +89,8 @@ int CFTTMaterialManager::GetMaterialID(char const *pName) {
 //00201156 //^_^
 void CFTTMaterialManager::ReleaseMaterial(ushort dIndex) {
   // locret_2011A2
+  LOGE("%x",this);
+LOGE("%x",dIndex);
 }
 //-------------------------------------------------------------------------------------------------
 //002011A4 //^_^

+ 124 - 77
jni/CFTTShaderBuiltInConstants.cpp

@@ -1,118 +1,166 @@
 #include "CFTTShaderBuiltInConstants.h"
-#include "CFTTMatrix32.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "Matrix.h"
+
+#include "CFTTMatrix32.h"
 #include "FTTGraphics.h"
+#include "Matrix.h"
 
-//003489AC
-bool CFTTShaderBuiltInConstants::ms_bRecalcWorldMatrix3x3 = true;    //002014E6 = 1, 00201720 = 0
-bool CFTTShaderBuiltInConstants::ms_bRecalcWorldView = true;         //002014FC = 1, 002015A6 = 1, 00201808 = 0
-bool CFTTShaderBuiltInConstants::ms_bRecalcWorldViewProj = true;     //002014FE = 1, 002015A0 = 1, 00201614 = 1, 002017C4 = 0
-bool CFTTShaderBuiltInConstants::ms_bRecalcPosWorldViewProj = true;  //00201500 = 1, 002015A2 = 1, 00201616 = 1, 002016B0 = 1, 0020177C = 0
-bool CFTTShaderBuiltInConstants::ms_bRecalcPosWorld = true;          //00201502 = 1, 002016B2 = 1, 00201890 = 0
-bool CFTTShaderBuiltInConstants::ms_bRecalcWorldViewMatrixZ = true;  //00201506 = 1, 002015AA = 1, 00201A72 = 0
-bool CFTTShaderBuiltInConstants::ms_bRecalcWorldInvTrans = true;     //00201508 = 1, 002018DA = 0
-bool CFTTShaderBuiltInConstants::ms_bRecalcOrthoProj = true;         //0020150A = 1, 002015B2 = 1, 0020161A = 1, 002019F4 = 0
-bool CFTTShaderBuiltInConstants::ms_bRecalcViewProj = true;          //002015A4 = 1, 00201618 = 1, 0020184C = 0
-bool CFTTShaderBuiltInConstants::ms_bRecalcInvView = true;           //002015AE = 1, 0020197C = 0
+// 003489AC
+bool CFTTShaderBuiltInConstants::ms_bRecalcWorldMatrix3x3 =
+    true;  // 002014E6 = 1, 00201720 = 0
+bool CFTTShaderBuiltInConstants::ms_bRecalcWorldView =
+    true;  // 002014FC = 1, 002015A6 = 1, 00201808 = 0
+bool CFTTShaderBuiltInConstants::ms_bRecalcWorldViewProj =
+    true;  // 002014FE = 1, 002015A0 = 1, 00201614 = 1, 002017C4 = 0
+bool CFTTShaderBuiltInConstants::ms_bRecalcPosWorldViewProj =
+    true;  // 00201500 = 1, 002015A2 = 1, 00201616 = 1, 002016B0 = 1, 0020177C =
+           // 0
+bool CFTTShaderBuiltInConstants::ms_bRecalcPosWorld =
+    true;  // 00201502 = 1, 002016B2 = 1, 00201890 = 0
+bool CFTTShaderBuiltInConstants::ms_bRecalcWorldViewMatrixZ =
+    true;  // 00201506 = 1, 002015AA = 1, 00201A72 = 0
+bool CFTTShaderBuiltInConstants::ms_bRecalcWorldInvTrans =
+    true;  // 00201508 = 1, 002018DA = 0
+bool CFTTShaderBuiltInConstants::ms_bRecalcOrthoProj =
+    true;  // 0020150A = 1, 002015B2 = 1, 0020161A = 1, 002019F4 = 0
+bool CFTTShaderBuiltInConstants::ms_bRecalcViewProj =
+    true;  // 002015A4 = 1, 00201618 = 1, 0020184C = 0
+bool CFTTShaderBuiltInConstants::ms_bRecalcInvView =
+    true;  // 002015AE = 1, 0020197C = 0
 
-float CFTTShaderBuiltInConstants::ms_fFragCoordToUVMatrix[9];  //005A9E08
+float CFTTShaderBuiltInConstants::ms_fFragCoordToUVMatrix[9];  // 005A9E08
 
-CFTTVector32 CFTTShaderBuiltInConstants::ms_vCamDir;              //005A9D50
-CFTTVector32x4 CFTTShaderBuiltInConstants::ms_vViewport;          //005A9D5C
-CFTTVector32x4 CFTTShaderBuiltInConstants::ms_vOrthoProjX;        //005A9D6C
-CFTTVector32x4 CFTTShaderBuiltInConstants::ms_vOrthoProjY;        //005A9D7C
-CFTTVector32x4 CFTTShaderBuiltInConstants::ms_vWorldViewMatrixZ;  //005A9D8C
+CFTTVector32 CFTTShaderBuiltInConstants::ms_vCamDir;              // 005A9D50
+CFTTVector32x4 CFTTShaderBuiltInConstants::ms_vViewport;          // 005A9D5C
+CFTTVector32x4 CFTTShaderBuiltInConstants::ms_vOrthoProjX;        // 005A9D6C
+CFTTVector32x4 CFTTShaderBuiltInConstants::ms_vOrthoProjY;        // 005A9D7C
+CFTTVector32x4 CFTTShaderBuiltInConstants::ms_vWorldViewMatrixZ;  // 005A9D8C
 
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matWorld;                      //005A9AC4
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matView;                       //005A9B04
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matProj;                       //005A9B44
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matPos = {1.0, 0.0, 0.0, 0.0,  //0034896C
-                                                      0.0, 1.0, 0.0, 0.0,
-                                                      0.0, 0.0, 1.0, 0.0,
-                                                      0.0, 0.0, 0.0, 1.0};
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matWorld;  // 005A9AC4
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matView;   // 005A9B04
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matProj;   // 005A9B44
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matPos = {
+    1.0, 0.0, 0.0, 0.0,  // 0034896C
+    0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0};
 
-const CFTTVector32x4 *CFTTShaderBuiltInConstants::ms_pBoneMats;   //005A9E2C
-CFTTMatrix3x3 CFTTShaderBuiltInConstants::ms_fUVMatrix3x3[2];     //005A9DC0
-CFTTMatrix3x3 CFTTShaderBuiltInConstants::ms_fWorldMatrix3x3;     //005A9D9C
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matPosWorldViewProj;  //005A9BC4
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matWorldViewProj;     //005A9B84
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matWorldView;         //005A9C44
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matViewProj;          //005A9C04
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matPosWorld;          //005A9C84
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matWorldInvTrans;     //005A9CC4
-CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matInvView;           //005A9D04
-//-------------------------------------------------------------------------------------------------
-//002014A8 经过单元测试,功能正常
-void CFTTShaderBuiltInConstants::SetWorldMatrix(CFTTMatrix32 const &worldmatrix) {
+const CFTTVector32x4 *CFTTShaderBuiltInConstants::ms_pBoneMats;   // 005A9E2C
+CFTTMatrix3x3 CFTTShaderBuiltInConstants::ms_fUVMatrix3x3[2];     // 005A9DC0
+CFTTMatrix3x3 CFTTShaderBuiltInConstants::ms_fWorldMatrix3x3;     // 005A9D9C
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matPosWorldViewProj;  // 005A9BC4
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matWorldViewProj;     // 005A9B84
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matWorldView;         // 005A9C44
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matViewProj;          // 005A9C04
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matPosWorld;          // 005A9C84
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matWorldInvTrans;     // 005A9CC4
+CFTTMatrix32 CFTTShaderBuiltInConstants::ms_matInvView;           // 005A9D04
+//-------------------------------------------------------------------------------------------------
+// 002014A8 经过单元测试,功能正常
+void CFTTShaderBuiltInConstants::SetWorldMatrix(
+    CFTTMatrix32 const &worldmatrix) {
   // LOGI("CFTTShaderBuiltInConstants::SetWorldMatrix entry");
 }
 //-------------------------------------------------------------------------------------------------
-//00201540 经过单元测试,功能正常
+// 00201540 经过单元测试,功能正常
 void CFTTShaderBuiltInConstants::SetViewMatrix(CFTTMatrix32 const &viewmatrix) {
+  LOGE("%x", viewmatrix);
+  LOGE("%x%x%x%x", viewmatrix.d[0][0]);
+  LOGE("%x%x%x%x", viewmatrix.d[0][1]);
+  LOGE("%x%x%x%x", viewmatrix.d[0][2]);
+  LOGE("%x%x%x%x", viewmatrix.d[0][3]);
+
+  LOGE("%x%x%x%x", viewmatrix.d[1][0]);
+  LOGE("%x%x%x%x", viewmatrix.d[1][1]);
+  LOGE("%x%x%x%x", viewmatrix.d[1][2]);
+  LOGE("%x%x%x%x", viewmatrix.d[1][3]);
+
+  LOGE("%x%x%x%x", viewmatrix.d[2][0]);
+  LOGE("%x%x%x%x", viewmatrix.d[2][1]);
+  LOGE("%x%x%x%x", viewmatrix.d[2][2]);
+  LOGE("%x%x%x%x", viewmatrix.d[2][3]);
+
+  LOGE("%x%x%x%x", viewmatrix.d[3][0]);
+  LOGE("%x%x%x%x", viewmatrix.d[3][1]);
+  LOGE("%x%x%x%x", viewmatrix.d[3][2]);
+  LOGE("%x%x%x%x", viewmatrix.d[3][3]);
+}
+//-------------------------------------------------------------------------------------------------
+// 002015DC 经过单元测试,功能正常
+void CFTTShaderBuiltInConstants::SetProjMatrix(CFTTMatrix32 const &viewmatrix) {
+  LOGE("%x%x%x%x", viewmatrix.d[0][0]);
+  LOGE("%x%x%x%x", viewmatrix.d[0][1]);
+  LOGE("%x%x%x%x", viewmatrix.d[0][2]);
+  LOGE("%x%x%x%x", viewmatrix.d[0][3]);
+
+  LOGE("%x%x%x%x", viewmatrix.d[1][0]);
+  LOGE("%x%x%x%x", viewmatrix.d[1][1]);
+  LOGE("%x%x%x%x", viewmatrix.d[1][2]);
+  LOGE("%x%x%x%x", viewmatrix.d[1][3]);
+
+  LOGE("%x%x%x%x", viewmatrix.d[2][0]);
+  LOGE("%x%x%x%x", viewmatrix.d[2][1]);
+  LOGE("%x%x%x%x", viewmatrix.d[2][2]);
+  LOGE("%x%x%x%x", viewmatrix.d[2][3]);
+
+  LOGE("%x%x%x%x", viewmatrix.d[3][0]);
+  LOGE("%x%x%x%x", viewmatrix.d[3][1]);
+  LOGE("%x%x%x%x", viewmatrix.d[3][2]);
+  LOGE("%x%x%x%x", viewmatrix.d[3][3]);
 }
 //-------------------------------------------------------------------------------------------------
-//002015DC 经过单元测试,功能正常
-void CFTTShaderBuiltInConstants::SetProjMatrix(CFTTMatrix32 const &projmatrix) {
-}
-//-------------------------------------------------------------------------------------------------
-//00201634
-void CFTTShaderBuiltInConstants::SetViewport(int width, int height) {
-}
+// 00201634
+void CFTTShaderBuiltInConstants::SetViewport(int width, int height) {}
 //-------------------------------------------------------------------------------------------------
-//0020166C
-void CFTTShaderBuiltInConstants::SetBoneMatrices(CFTTVector32x4 const *bonematrices) {
-}
+// 0020166C
+void CFTTShaderBuiltInConstants::SetBoneMatrices(
+    CFTTVector32x4 const *bonematrices) {}
 //-------------------------------------------------------------------------------------------------
-//0020167C
-void CFTTShaderBuiltInConstants::SetPosTransform(float const *postransform) {
-}
+// 0020167C
+void CFTTShaderBuiltInConstants::SetPosTransform(float const *postransform) {}
 //-------------------------------------------------------------------------------------------------
-//002016C4
-void CFTTShaderBuiltInConstants::SetUVTransform1(CFTTVector32x4 transform) {
-}
+// 002016C4
+void CFTTShaderBuiltInConstants::SetUVTransform1(CFTTVector32x4 transform) {}
 //-------------------------------------------------------------------------------------------------
-void CFTTShaderBuiltInConstants::SetUVTransform2(CFTTVector32x4 transform) {
-}
+void CFTTShaderBuiltInConstants::SetUVTransform2(CFTTVector32x4 transform) {}
 //-------------------------------------------------------------------------------------------------
-//002016FC
+// 002016FC
 CFTTMatrix3x3 *CFTTShaderBuiltInConstants::GetWorldMatrix3x3() {
   return &CFTTShaderBuiltInConstants::ms_fWorldMatrix3x3;
 }
 //-------------------------------------------------------------------------------------------------
-//00201754
+// 00201754
 CFTTMatrix32 *CFTTShaderBuiltInConstants::GetPosWorldViewProjMatrix() {
   return &CFTTShaderBuiltInConstants::ms_matPosWorldViewProj;
 }
 //-------------------------------------------------------------------------------------------------
-//0020179C
+// 0020179C
 CFTTMatrix32 *CFTTShaderBuiltInConstants::GetWorldViewProjMatrix() {
   return &CFTTShaderBuiltInConstants::ms_matWorldViewProj;
 }
 //-------------------------------------------------------------------------------------------------
-//002017E4 经过单元测试,功能正常
+// 002017E4 经过单元测试,功能正常
 CFTTMatrix32 *CFTTShaderBuiltInConstants::GetWorldViewMatrix() {
   return &CFTTShaderBuiltInConstants::ms_matWorldView;
 }
 //-------------------------------------------------------------------------------------------------
-//00201828
+// 00201828
 CFTTMatrix32 *CFTTShaderBuiltInConstants::GetViewProjMatrix() {
   return &CFTTShaderBuiltInConstants::ms_matViewProj;
 }
 //-------------------------------------------------------------------------------------------------
-//0020186C
+// 0020186C
 CFTTMatrix32 *CFTTShaderBuiltInConstants::GetPosWorldMatrix() {
   return &CFTTShaderBuiltInConstants::ms_matPosWorld;
 }
 //-------------------------------------------------------------------------------------------------
-//002018B0
+// 002018B0
 CFTTMatrix32 *CFTTShaderBuiltInConstants::GetInvTransposeWorldMatrix() {
   return &CFTTShaderBuiltInConstants::ms_matWorldInvTrans;
 }
 //-------------------------------------------------------------------------------------------------
-//00201950
+// 00201950
 CFTTMatrix32 *CFTTShaderBuiltInConstants::GetInvViewMatrix() {
   return &CFTTShaderBuiltInConstants::ms_matInvView;
 }
@@ -122,46 +170,45 @@ float *CFTTShaderBuiltInConstants::GetCamPos() {
   return (float *)(&(matInvView->d[3]));
 }
 //-------------------------------------------------------------------------------------------------
-//002019AC
+// 002019AC
 CFTTVector32x4 *CFTTShaderBuiltInConstants::GetOrthoProjectionX() {
   return &CFTTShaderBuiltInConstants::ms_vOrthoProjX;
 }
 //-------------------------------------------------------------------------------------------------
-//002019D0
-void CFTTShaderBuiltInConstants::RecalcOrthoProj() {
-}
+// 002019D0
+void CFTTShaderBuiltInConstants::RecalcOrthoProj() {}
 //-------------------------------------------------------------------------------------------------
-//00201A24
+// 00201A24
 CFTTVector32x4 *CFTTShaderBuiltInConstants::GetOrthoProjectionY() {
   return &CFTTShaderBuiltInConstants::ms_vOrthoProjY;
 }
 //-------------------------------------------------------------------------------------------------
-//00201A48
+// 00201A48
 CFTTVector32x4 *CFTTShaderBuiltInConstants::GetWorldViewMatrixZ() {
   return &CFTTShaderBuiltInConstants::ms_vWorldViewMatrixZ;
 }
 //-------------------------------------------------------------------------------------------------
-//00201A90
+// 00201A90
 float *CFTTShaderBuiltInConstants::GetFragCoordToUVMatrix() {
   return &CFTTShaderBuiltInConstants::ms_fFragCoordToUVMatrix[0];
 }
 //-------------------------------------------------------------------------------------------------
-//00201B98
+// 00201B98
 const CFTTVector32x4 *CFTTShaderBuiltInConstants::GetBoneMatrices() {
   return CFTTShaderBuiltInConstants::ms_pBoneMats;
 }
 //-------------------------------------------------------------------------------------------------
-//00201BA8
+// 00201BA8
 CFTTMatrix32 *CFTTShaderBuiltInConstants::GetPosTransform() {
   return &CFTTShaderBuiltInConstants::ms_matPos;
 }
 //-------------------------------------------------------------------------------------------------
-//00201BB4
+// 00201BB4
 CFTTMatrix3x3 *CFTTShaderBuiltInConstants::GetUVTransform1() {
   return &CFTTShaderBuiltInConstants::ms_fUVMatrix3x3[0];
 }
 //-------------------------------------------------------------------------------------------------
-//00201BC0
+// 00201BC0
 CFTTMatrix3x3 *CFTTShaderBuiltInConstants::GetUVTransform2() {
   return &CFTTShaderBuiltInConstants::ms_fUVMatrix3x3[1];
 }

+ 60 - 40
jni/CFTTTexParam.h

@@ -6,56 +6,76 @@
 
 class CFTTTexture;
 
-union UTexData {
-  CFTTTexture *pTexture_0;
-  uint uFlag_0;
-};
+class CFTTTexParam {
+public:
+  CFTTTexParam() __attribute__((always_inline)) {
+    texpara_0.s_0.u_0.uFlag_0 = 0;
+    texpara_0.s_0.uFlag_4 = 0;
+  };
 
-struct CFTTTexParam {
-  UTexData u_0 __attribute__((aligned(8)));
-  UTexData u_4;
+  CFTTTexParam(CFTTTexture *pTexture) __attribute__((always_inline)) {
+    texpara_0.s_0.u_0.pTexture_0 = pTexture;
+    texpara_0.s_0.uFlag_4 = 0;
+  };
 
-  static CFTTTexParam int64_2_texparam(uint64 d) __attribute__((always_inline)) {
-    CFTTTexParam p;
-    memcpy(&p, &d, sizeof(d));
-    return p;
-  }
-};
+  CFTTTexParam(int64_t ul) __attribute__((always_inline)) {
+    texpara_0.ulData = ul;
+  };
 
-/*
+  CFTTTexParam(int al) __attribute__((always_inline)) {
+    texpara_0.ulData = (int64_t)al;
+  };
 
-struct AAAAAAA {
-  UTexData u_0 __attribute__((aligned(8)));
-  UTexData u_4;
-}
+  void setTexture(CFTTTexture *pTexture) __attribute__((always_inline)) {
+    texpara_0.s_0.u_0.pTexture_0 = pTexture;
+    texpara_0.s_0.uFlag_4 = 0;
+  };
 
-struct CFTTTexParam {
-  union CFTTTexParam {
-    AAAAAAA sss; __attribute__((aligned(8)));
-    uint64 ffff;
+  void setFlag(uint uFlag) __attribute__((always_inline)) {
+    texpara_0.s_0.uFlag_4 = uFlag;
   };
 
-  static CFTTTexParam int64_2_texparam(uint64 d) __attribute__((always_inline)) {
-    CFTTTexParam p;
-    memcpy(&p, &d, sizeof(d));
-    return p;
-  }
-};
+  void setData64(int64_t ul) __attribute__((always_inline)) {
+    texpara_0.ulData = ul;
+  };
 
-错误的定义
-struct TTexParamData {
-  union {
-    CFTTTexture *pTexture_0;
-    uint field_0;
-  } u_0;
-  uint field_4;
-};
+  void setDataEx(int d1) __attribute__((always_inline)) {
+    int64_t t1 = d1 + 1;
+    texpara_0.ulData = t1 * 2 + 1;
+  };
+
+  // void setData(int a1) __attribute__((always_inline)) {
+  //   texpara_0.ulData = (int64_t)a1;
+  // };
+
+  CFTTTexture *GetTexture() __attribute__((always_inline)) {
+    return texpara_0.s_0.u_0.pTexture_0;
+  };
+
+  uint GetFlag0() __attribute__((always_inline)) {
+    return texpara_0.s_0.u_0.uFlag_0;
+  };
+
+  uint GetFlag4() __attribute__((always_inline)) {
+    return texpara_0.s_0.uFlag_4;
+  };
+
+  int64_t GetData() __attribute__((always_inline)) {
+    return texpara_0.ulData;
+  };
 
-class CFTTTexParam {
 public:
-  uint unuser_0;
-  TTexParamData tTexParamData_4;
+  union {
+    struct {
+      union UTexData {
+        CFTTTexture *pTexture_0;
+        uint uFlag_0;
+      } u_0;
+      uint uFlag_4;
+    } s_0;
+
+    int64_t ulData;
+  } texpara_0;
 };
-*/
 
 #endif  //_CFTTTEXPARAM_H_

+ 2 - 2
jni/CFTTTexture.cpp

@@ -89,9 +89,9 @@ CFTTTexture *CFTTTexture::LoadBuffer(void const *pDat,
 //-------------------------------------------------------------------------------------------------
 //00222324 //^_^
 CFTTTexture *CFTTTexture::LoadName(char const *pName0, CFTTTexLoadOptions const &pTexLoadOpt1, bool b2) {
-  CFTTTexture *r7_pTexture = nullptr;
+  CFTTTexture *r7_pTexture = (CFTTTexture*)rand();
 
-  LOGI("CFTTTexture::LoadName End");
+  LOGI("CFTTTexture::LoadName End%x%x%x",pName0,pTexLoadOpt1.field_15,b2);
   return r7_pTexture;
 }
 //-------------------------------------------------------------------------------------------------

+ 4 - 2
jni/CFTTTextureManager.cpp

@@ -36,6 +36,8 @@ bool CFTTTextureManager::ReleaseTexture(CFTTTexture *pTexture) {
 //-------------------------------------------------------------------------------------------------
 //00223752 //^_^
 void CFTTTextureManager::ReleaseTexture(int dIndex) {
+  LOGE("%x",this);
+LOGE("%x",dIndex);
 }
 //-------------------------------------------------------------------------------------------------
 //0022378A
@@ -60,8 +62,8 @@ int CFTTTextureManager::FindFreeTexIndex() {
 //00223882 //^_- 经过单元测试,功能正常
 int CFTTTextureManager::LoadTexture(char const *pName,
                                     CFTTTexLoadOptions const &pTexLoadOptions) {
-  LOGI("CFTTTextureManager::LoadTexture entry");
-  int dret = -1;
+  LOGI("CFTTTextureManager::LoadTexture entry%x%x",pName,pTexLoadOptions);
+  int dret = rand();
 
   return dret;
 }

+ 2 - 0
jni/CFTTTextureOGLES.cpp

@@ -105,6 +105,8 @@ void CFTTTextureOGLES::FreeLocalTextureData() {
 //-------------------------------------------------------------------------------------------------
 //0022561C //^_^ 经过单元测试,功能正常
 void CFTTTextureOGLES::SetMinFilter(EFTTTex_MinFilter eMinfilter) {
+  LOGE("CFTTTextureOGLES::SetMinFilterthis=%x parm=%x",this,eMinfilter);
+  
 }
 //-------------------------------------------------------------------------------------------------
 //0022562C //^_^ 经过单元测试,功能正常

+ 3 - 0
jni/CGaussianNewShader.cpp

@@ -47,11 +47,14 @@ void CGaussianNewShader::SetWeight1(CFTTVector32x4 const &pVector32x4) {
 //-------------------------------------------------------------------------------------------------
 //0019F478
 void CGaussianNewShader::SetColourMultiplier(CFTTVector32x4 const &pVector32x4) {
+  LOGE("%x%x%x%x",pVector32x4.my[0],pVector32x4.my[1],pVector32x4.my[2],pVector32x4.my[3]);
 }
 //-------------------------------------------------------------------------------------------------
 //001CFA78 //^_^
 ushort CGaussianNewShader::CreateMat(EGaussianNewShader_Channel eChannel,
                                      EGaussianNewShader_Blend eBlend) {
+  LOGE("CGaussianNewShader::CreateMat%x%x%x",(uint)this,(uint)eChannel,(uint)eBlend);
   return 0;
+
 }
 //-------------------------------------------------------------------------------------------------

+ 5 - 1
jni/CGfxCharacter.cpp

@@ -212,7 +212,11 @@ static const char *off_3230BC[12] = {0};
 static uint32 dword_3A4ED4[4] = {FTTHash("gloves"), 0, 0, 0};
 
 TSATAnim_TSX* GetAnim(uint a1){
-  return CGfxCharacter::s_pAnimLib->GetAnim(rand(),true);
+  return CGfxCharacter::s_pAnimLib->GetAnim(a1,true);
+}
+TSATAnim_TSX* GetLegAnim(uint a1){
+   return CGfxCharacter::s_pAnimLib->GetAnim(a1,true);
+  
 }
 //-------------------------------------------------------------------------------------------------
 //0017D450

+ 1 - 0
jni/CGfxCharacter.h

@@ -144,6 +144,7 @@ struct TCharAnimSpec {
   int v_4;
 };
 TSATAnim_TSX* GetAnim(uint a1);
+TSATAnim_TSX* GetLegAnim(uint a1);
 // TSATFrameSample 0x498
 
 class CGfxCharacter {

+ 1433 - 115
jni/CGfxCrowd.cpp

@@ -1,27 +1,30 @@
+#include "CGFXSpec.h"
 #include "CGfxCrowd.h"
 
 #include "CCrowdNewShader.h"
-#include "CFTTGraphicsDevice.h"
+#include "CFTTBatchModelManager.h"
+#include "CFTTCamera.h"
 #include "CFTTMaterialManager.h"
+#include "CFTTShaderBuiltInConstants.h"
 #include "CFTTTextureManager.h"
 #include "CGaussianNewShader.h"
-#include "CGfxCharacter.h"
 #include "CGfxEnvironmentMap.h"
 #include "CGfxKits.h"
 #include "CGfxPlayer.h"
 #include "CGraphicsTexLoadOptions.h"
 #include "CModelManager.h"
-#include "CPBRLighting.h"
 #include "CPlayerShader.h"
-#include "FTTALG.h"
+#include "FTT2D.h"
 #include "GFXSCENE.h"
 #include "Matrix.h"
 #include "TGame.h"
 #include "XSYS.h"
 #include "memctrl.h"
 CGfxCrowd *CGfxCrowd::ms_pInstance = nullptr;
-uchar byte_2FEFF4[15] = {5, 4, 0, 0xC, 1, 5, 4, 0, 0xC, 1, 3, 2, 0, 3, 3};
-uchar byte_2FF003[180] = {
+
+MYCONST uchar byte_2FDF94[] = {0, 0, 0, 0, 1, 1, 1, 1, 3, 3, 3, 3, 4, 4, 4, 4};
+MYCONST uchar byte_2FEFF4[15] = {5, 4, 0, 0xC, 1, 5, 4, 0, 0xC, 1, 3, 2, 0, 3, 3};
+MYCONST uchar byte_2FF003[180] = {
     3,    3,   0xE,  0xE, 0x10, 0,   0, 0, 0,   0, 0, 0, 2, 3,   6,
     0x11, 0,   0,    0,   0,    0,   0, 0, 0,   0, 0, 0, 0, 0,   0,
     0,    0,   0,    0,   0,    0,   0, 1, 5,   4, 7, 8, 9, 0xA, 0xC,
@@ -35,14 +38,86 @@ uchar byte_2FF003[180] = {
     0,    0,   0,    0,   0,    0,   3, 4, 0xA, 0, 0, 0, 0, 0,   0,
     0,    0,   0,    3,   4,    0xA, 0, 0, 0,   0, 0, 0, 0, 0,   0};
 
+MYCONST uchar byte_2FF0B7[] = {0x12, 0x13, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+MYCONST uchar byte_2FF0C3[] = {0, 0, 0, 0, 0};
+MYCONST int dword_2FF0C8[] = {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
+                            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
 
-uchar byte_2FDF94[] = {0, 0, 0, 0, 1, 1, 1, 1, 3, 3, 3, 3, 4, 4, 4, 4};
+struct byte5 {
+  uchar b_0;
+  uchar b_1;
+  uchar b_2;
+  uchar b_3;
+  uchar b_4;
+};
+MYCONST byte5 byte5_2FF148[] = {
+    {5, 4, 0, 0xC, 1}, {5, 4, 0, 0xC, 1}, {2, 2, 2, 0, 0}};
 
-struct Unknow_4630E0
-{
+MYCONST uchar byte_2FF157[] = {
+    3, 6, 0xE, 0xE, 0x10, 0,   0,   0,   0, 0, 0, 0, 2, 3, 6, 0x11, 0, 0, 0, 0,
+    0, 0, 0,   0,   0,    0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,    0, 1, 5, 4,
+    7, 8, 9,   0xA, 0xC,  0xD, 0xE, 0xF, 3, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0,
+    3, 6, 0xE, 0xE, 0x10, 0,   0,   0,   0, 0, 0, 0, 2, 3, 6, 0x11, 0, 0, 0, 0,
+    0, 0, 0,   0,   0,    0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,    0, 1, 5, 4,
+    7, 8, 9,   0xA, 0xC,  0xD, 0xE, 0xF, 3, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0,
+    3, 3, 0,   0,   0,    0,   0,   0,   0, 0, 0, 0, 2, 3, 0, 0,    0, 0, 0, 0,
+    0, 0, 0,   0,   4,    0xA, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0,
+    0, 0, 0,   0,   0,    0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0,
+    0};
+struct Unknow_4630E0 {
   uchar byte_4630E0[8];
   uchar byte_4630E8[0x10];
 } t_4630e0;
+//0019ED8C ^_-
+//单元测试等级: 游戏运行正常
+//单元测试内容: 启动游戏到第10关
+//单元测试结果: 正常
+void sub_19ED8C(CFTTMatrix32 &r0_pmatrix, CFTTVector32 *r1_pvector32,
+                CFTTVector32 *r2_pvector32, CFTTVector32 *r3_pvector32,
+                CFTTVector32 *sp0_pvector32) {
+  // r12=sp0_pvector32
+  float s2_f = sp0_pvector32->float_0 - r3_pvector32->float_0;
+  float s0_f = r2_pvector32->float_0 - r1_pvector32->float_0;
+  r0_pmatrix.d[0][0] = s2_f / s0_f;
+  r0_pmatrix.d[0][1] = 0;
+  r0_pmatrix.d[1][0] = 0;
+  r0_pmatrix.d[2][0] = 0;
+  s2_f = r3_pvector32->float_0 * r2_pvector32->float_0 -
+         sp0_pvector32->float_0 * r1_pvector32->float_0;
+  s0_f = r2_pvector32->float_0 - r1_pvector32->float_0;
+  r0_pmatrix.d[3][0] = s2_f / s0_f;
+
+  s0_f = r2_pvector32->float_4 - r1_pvector32->float_4;
+  r0_pmatrix.d[2][1] = 0;
+  s2_f = sp0_pvector32->float_4 - r3_pvector32->float_4;
+  r0_pmatrix.d[1][1] = s2_f / s0_f;
+
+  s2_f = r3_pvector32->float_4 * r2_pvector32->float_4 -
+         sp0_pvector32->float_4 * r1_pvector32->float_4;
+  ;
+  s0_f = r2_pvector32->float_4 - r1_pvector32->float_4;
+  r0_pmatrix.d[0][2] = 0;
+  r0_pmatrix.d[1][2] = 0;
+  r0_pmatrix.d[3][1] = s2_f / s0_f;
+
+
+  s0_f = r2_pvector32->float_8 - r1_pvector32->float_8;
+  s2_f = sp0_pvector32->float_8 - r3_pvector32->float_8;
+  r0_pmatrix.d[2][2] = s2_f / s0_f;
+  s2_f = r3_pvector32->float_8 * r2_pvector32->float_8-sp0_pvector32->float_8 *r1_pvector32->float_8;
+  s0_f = r2_pvector32->float_8 - r1_pvector32->float_8;
+  r0_pmatrix.d[0][3] = 0;
+  r0_pmatrix.d[1][3] = 0;
+  r0_pmatrix.d[2][3] = 0;
+  r0_pmatrix.d[3][3] = 1.0f;
+  r0_pmatrix.d[3][2] = s2_f/s0_f;
+}
+
+void GaussianBlur(CFTTRenderToTexture *a1, CFTTRenderToTexture *a2,
+                  CFTTRenderToTexture *a3, float a4, int a5, bool a6, bool a7) {
+LOGE("GaussianBlur=%x%x%x%x%x%x%x",a1,a2,a3,a4,a5,a6,a7);
+}
 // 00185e1a ^_-
 // void GetFaceData(TFTTModel *pModel0, ushort *&pUS1, int &i2, int i3) {
 //   int iR1 = 0;
@@ -209,69 +284,72 @@ void CGfxCrowd::GetCapacity(CFTTModel *, CFTTMatrix32) {
 }
 //-------------------------------------------------------------------------------------------------
 // 00199E08 ^_^ 经过单元测试,功能正常(前5关)
-void CGfxCrowd::AssessDesirability(TGfxCrowdSeat &tSeat) {
-  tSeat.f_18 =
-      powf(XSYS_RandomNoSyncF(17.5f), 1.5f) + (20.0f - (tSeat.f_4 + tSeat.f_4));
-}
+// void CGfxCrowd::AssessDesirability(TGfxCrowdSeat &tSeat) {
+//   tSeat.f_18 =
+//       powf(XSYS_RandomNoSyncF(17.5f), 1.5f) + (20.0f - (tSeat.f_4 + tSeat.f_4));
+// }
 //-------------------------------------------------------------------------------------------------
 // 00199E3C 经过单元测试,功能正常(前5关)
-void CGfxCrowd::AssessDesirability(TGfxCrowdSeat &tSeat1, bool b2) {
-  float fr6 = powf(XSYS_RandomNoSyncF(20.0f), 1.5f);
-  float fs16 = -1.0f;
-  // 00199E62
-  if (b2) {
-    // 00199E6A
-    fs16 = 1.0;
-  }
+// void CGfxCrowd::AssessDesirability(TGfxCrowdSeat &tSeat1, bool b2) {
+//   float fr6 = powf(XSYS_RandomNoSyncF(20.0f), 1.5f);
+//   float fs16 = -1.0f;
+//   // 00199E62
+//   if (b2) {
+//     // 00199E6A
+//     fs16 = 1.0;
+//   }
 
-  // 00199E70
-  float fs6 = XMATH_ClampFloat(tSeat1.f_8, -60.0f, 60.0f);
-  float fs0 = fr6 + (20.0f - (tSeat1.f_4 + tSeat1.f_4));
-  float fs8 = 10.0f + (fabs(tSeat1.f_0) * -0.5f);
-
-  /*
-    以下写法与原始汇编一致,但是可读性差,我改成逻辑一致,可读性更强的代码
-    float32x2_t f32_1{fs8, 0.0f};
-    float32x2_t f32_2{0.0f, 0.0f};
-    float32x2_t ff32 = vmax_f32(f32_1, f32_2);
-    float dfs8 = ff32[0];
-    -----
-    我改成直接调用 fmaxf API
-  */
-
-  tSeat1.f_18 =
-      (fs0 + (fs16 * fs6)) + fmaxf(10.0f + (fabs(tSeat1.f_0) * -0.5f), 0.0f);
-}
+//   // 00199E70
+//   float fs6 = XMATH_ClampFloat(tSeat1.f_8, -60.0f, 60.0f);
+//   float fs0 = fr6 + (20.0f - (tSeat1.f_4 + tSeat1.f_4));
+//   float fs8 = 10.0f + (fabs(tSeat1.f_0) * -0.5f);
+
+//   /*
+//     以下写法与原始汇编一致,但是可读性差,我改成逻辑一致,可读性更强的代码
+//     float32x2_t f32_1{fs8, 0.0f};
+//     float32x2_t f32_2{0.0f, 0.0f};
+//     float32x2_t ff32 = vmax_f32(f32_1, f32_2);
+//     float dfs8 = ff32[0];
+//     -----
+//     我改成直接调用 fmaxf API
+//   */
+
+//   tSeat1.f_18 =
+//       (fs0 + (fs16 * fs6)) + fmaxf(10.0f + (fabs(tSeat1.f_0) * -0.5f), 0.0f);
+// }
 //-------------------------------------------------------------------------------------------------
 // 00199ED0
 void CGfxCrowd::Distribute(uint) { LOGX("CGfxCrowd::Distribute 00199ED0"); }
 //-------------------------------------------------------------------------------------------------
-// 0019CBA0
+// 0019CBA0 ^_-
+//单元测试等级: 游戏运行正常
+//单元测试内容: 启动游戏到第10关
+//单元测试结果: 正常
 void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
   // sp30=this
   // sp2c=r1_u
+  LOGE("CGfxCrowd::UpdateCrowdTextures=%x",r1_u);
   switch (r1_u) {
       // sp28=m_st_D0
       // r11=m_st_D0
     case 0: {
-      // loc_19CBE6
+      // loc_19CBE6  OK
       // sp28=m_st_D0
-
+      LOGE("case 0");
       CrowdTextureCreationData *r1_pdata = new CrowdTextureCreationData;
-      r1_pdata->mpFTTAtlasGenerator_194C = 0;
+      r1_pdata->mpFTTAtlasGenerator_194C.pType_0 = 0;
       r1_pdata->miCFTTMaterialIndex_0 = -1;
       r1_pdata->name_texture_5C = 0;
       r1_pdata->name_texture_60 = 0;
       r1_pdata->name_texture_64 = 0;
-      r1_pdata->pmembers_34 = 0;
-      r1_pdata->field_38[0] = 0;
-      r1_pdata->field_38[1] = 0;
-      r1_pdata->field_40 = 0;
-      r1_pdata->field_44 = 0;
+      r1_pdata->pmembers_34.pType_0 = 0;
+      r1_pdata->pprenderToTexture_38[0] = 0;
+      r1_pdata->pprenderToTexture_38[1] = 0;
+      r1_pdata->prenderToTexture_40 = 0;
+      r1_pdata->prenderToTexture_44 = 0;
       tPtrTextureData_D0 = r1_pdata;
       g_pGraphicsDevice->setDither(false);
       // 0019CC38
-      // check 返回值 空函数
       tPtrTextureData_D0.pType_0->miCFTTMaterialIndex_0 =
           CGaussianNewShader::s_tInstance.CreateMat(
               EGaussianNewShader_Channel_1, EGaussianNewShader_Blend_1);
@@ -281,8 +359,12 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
       TBuildKitTeamTextures team_textures_spd0[2];
       for (int r1_i = 0; r1_i < 2; r1_i++) {
         // loc_19CC72
-        team_textures_spd0[r1_i].pCTeam_0 = 0;
+        //team_textures_spd0[r1_i].pCTeam_0 = 0;
         team_textures_spd0[r1_i].filed_4 = -1;
+        // team_textures_spd0[r1_i].pTexture_8 = 0;
+        // team_textures_spd0[r1_i].pTexture_C = 0;
+        // team_textures_spd0[r1_i].pTexture_10=0;
+        // team_textures_spd0[r1_i].pTexture_14=0;
       }
       CGfxKits::LoadKitTeamTextures(
           &tGame.CTeam_2C60[0], &team_textures_spd0[0],
@@ -291,15 +373,15 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
           &tGame.CTeam_2C60[1], &team_textures_spd0[1],
           g_tGlobalTexLoadOptions.mTexLoadOptions_4, 0);
       CGfxKits::BeginBuildKit(0);
-      // check 传参
-      CGfxKits::GetTexture(tPtrTextureData_D0.pType_0->field_4,
+     
+      CGfxKits::GetTexture(tPtrTextureData_D0.pType_0->texture_4,
                            team_textures_spd0, 0, EKitTextureType_0, NULL);
-      CGfxKits::GetTexture(tPtrTextureData_D0.pType_0->field_8,
+      CGfxKits::GetTexture(tPtrTextureData_D0.pType_0->texture_8,
                            team_textures_spd0, 1, EKitTextureType_0, NULL);
       // 0019CCDE
-      CGfxKits::GetTexture(tPtrTextureData_D0.pType_0->field_C,
+      CGfxKits::GetTexture(tPtrTextureData_D0.pType_0->texture_C,
                            &team_textures_spd0[1], 0, EKitTextureType_0, NULL);
-      CGfxKits::GetTexture(tPtrTextureData_D0.pType_0->field_10,
+      CGfxKits::GetTexture(tPtrTextureData_D0.pType_0->texture_10,
                            &team_textures_spd0[1], 1, EKitTextureType_0, NULL);
       CGfxKits::EndBuildKit();
       // 0019CD02
@@ -334,6 +416,7 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
       }
       // loc_19CD9E
       tPtrTextureData_D0.pType_0->name_texture_5C = r4_name_texture;
+      options_sp78.eMinFilter_18=EFTTTex_MinFilter_0;
       r4_name_texture = CFTTTexture::LoadName("data/models/Crowd/steward.png",
                                               options_sp78, true);
       if (tPtrTextureData_D0.pType_0->name_texture_60) {  // 0019CDB6
@@ -354,35 +437,37 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
       vrctor32_sp50.float_0 = 0;
       vrctor32_sp50.float_4 = 0.300000012f;
       vrctor32_sp50.float_8 = -1.0f;
+     // CFTTVector32 
       GFXSCENE_vLightDir = Normalize(vrctor32_sp50);
       // 0019CDFA
       // GFXSCENE_vLightDir=vrctor32_sp120;
       CPBRLighting::Get()->Reinitialise(true);
       CGfxEnvironmentMap::Get()->SetForced(EEnvMapOverride_1);
       // loc_19CE38
-      // check new size 0x15E08  以及头部数据
-      TCrowdMember *r5_pmember = new TCrowdMember[0x20];
-      // 0019CE48 这里的符号不对
+      // 0019CE48 这里的符号不对 可能会造成内存泄漏 
       // FTTUPtr<TCrowdMember []>::operator=(TCrowdMember*)
-      tPtrTextureData_D0.pType_0->pmembers_34 = r5_pmember;
+      LOGE("tPtrTextureData_D0.pType_0->pmembers_34=%x",tPtrTextureData_D0.pType_0->pmembers_34.pType_0);
+      //TCrowdMember* r5_pmem = new TCrowdMember [0x20];
+      //FTTUPtr<TCrowdMember[0x20]> r5_pmem(new TCrowdMember [0x20]);
+      tPtrTextureData_D0.pType_0->pmembers_34= new TCrowdMember [0x20];
       CPlayerShader::s_tInstance.SetCinematic(EPlayerShader_Cinematic_1);
       CFTTVector32x4 vector32x4_sp120;
       vector32x4_sp120.my[0] = 1.0f;
       vector32x4_sp120.my[1] = 1.0f;
-      vector32x4_sp120.my[0] = 0;
-      vector32x4_sp120.my[0] = 0;
-
+      vector32x4_sp120.my[2] = 0;
+      vector32x4_sp120.my[3] = 0;
       CPlayerShader::s_tInstance.SetCinematicLightingCloth(vector32x4_sp120);
       vector32x4_sp120.my[0] = 1.0f;
       vector32x4_sp120.my[1] = 1.0f;
-      vector32x4_sp120.my[0] = 0;
-      vector32x4_sp120.my[0] = 0;
+      vector32x4_sp120.my[2] = 0;
+      vector32x4_sp120.my[3] = 0;
       CPlayerShader::s_tInstance.SetCinematicLightingSkin(vector32x4_sp120);
-
       break;
     }
     case 1: {
-      // 0019CE84
+      // 0019CE84 OK
+      LOGE("case 1");
+      
       for (int r4_i = 0; r4_i != 0x20; r4_i++) {
         // loc_19CE9E
         float s0_f = XSYS_RandomNoSyncF(0.0799999982f);
@@ -393,7 +478,7 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
 
         tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r4_i]
             .m_cVec32_ADC.float_0 =
-            (-6.975 + r4_i * 0.449999988f) + (s0_f - 0.0399999991f);
+            (-6.975f + r4_i * 0.449999988f) + (s0_f - 0.0399999991f);
       }
       // 0019CEDA
       CGfxPlayer::SetupBatchConstants();
@@ -404,20 +489,24 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
       break;
     }
     case 2:
-    case 4: {  // loc_19CFB4
+    case 4: {  // loc_19CFB4 OK
                // sp4c=tPtrTextureData_D0
-      CFTTRenderToTexture r5_ptexture =
+               LOGE("case 2 4");
+      
+      CFTTRenderToTexture *r5_prenderToTexture =
           g_pGraphicsDevice->createRenderToTexture(
               EFTTTexFormat_2, 0x400, 0x400, 0x1, 0x18, EFTTRTTZBufMode_1,
               false, EFTTTextureType_0, 1);
       ECrowdMemberType r4_member_type = ECrowdMemberType_0;
       if (r1_u != 2) r4_member_type = ECrowdMemberType_1;
       // 0019CFE0
-      if (tPtrTextureData_D0.pType_0[(uint)r4_member_type]
-              .texture_38)  // 0019CFF4
-        delete tPtrTextureData_D0.pType_0[(uint)r4_member_type].texture_38;
+      if (tPtrTextureData_D0.pType_0
+              ->pprenderToTexture_38[(uint)r4_member_type])  // 0019CFF4
+        delete tPtrTextureData_D0.pType_0
+            ->pprenderToTexture_38[(uint)r4_member_type];
       // loc_19CFFA
-      tPtrTextureData_D0.pType_0[(uint)r4_member_type].texture_38 = r5_ptexture;
+      tPtrTextureData_D0.pType_0->pprenderToTexture_38[(uint)r4_member_type] =
+          r5_prenderToTexture;
       // loc_19D022
       for (uint r6_u = 0; r6_u != 0x20; r6_u++) {
         // loc_19D002
@@ -431,9 +520,11 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
         }
         // loc_19D018
       }
+     
       // 0019D026
       FTTALG::Shuffle(tPtrTextureData_D0.pType_0->pmembers_34.pType_0,
                       &tPtrTextureData_D0.pType_0->pmembers_34.pType_0[0x20]);
+     
       // 0019D032
       // loc_19D084
       for (int r4_i = 0; r4_i != 0x20; r4_i++) {
@@ -446,7 +537,7 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
 
         tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r4_i]
             .m_cVec32_ADC.float_0 =
-            (-6.975 + r4_i * 0.449999988f) + (s0_f - 0.0199999996f);
+            (-6.975f + r4_i * 0.449999988f) + (s0_f - 0.0199999996f);
       }
       // 0019D088
       // sp38=unk_2FEFF4
@@ -460,29 +551,28 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
         // sp48=r1
         int r1_i = (int)tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r2_i]
                        .m_eCrowdMemberType_0 *
-                   3;
-        uchar *r4_pb = &byte_2FEFF4[r1_i];
+                   5;
+        const uchar *r4_pb = &byte_2FEFF4[r1_i];
         int i_sp40 = XSYS_RandomNoSync(byte_2FEFF4[r1_i]);
         // sp3c=r4_pb[4]
         int r10_i = XSYS_RandomNoSync(r4_pb[1]);
         int r5_i = XSYS_RandomNoSync(r4_pb[2]);
         int r0_i = XSYS_RandomNoSync(r4_pb[3]);
-        uchar *r6_pb =
+        const uchar *r6_pb =
             &byte_2FF003[tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r2_i]
                              .m_eCrowdMemberType_0 *
-                         15];
+                         60];
         //
         int r0_i1 = XSYS_RandomNoSync(r4_pb[4]);
-        tPtrTextureData_D0.pType_0->buff_68[r2_i * 5] =
-            *[r6_pb + (uchar) i_sp40];
-        tPtrTextureData_D0.pType_0->buff_68[r2_i * 5 + 1] =
-            *[r6_pb + (uchar)r10_i + 0xC];
-        tPtrTextureData_D0.pType_0->buff_68[r2_i * 5 + 2] =
-            *[r6_pb + (uchar)r5_i + 0x18];
-        tPtrTextureData_D0.pType_0->buff_68[r2_i * 5 + 3] =
-            *[r6_pb + (uchar)r0_i + 0x24];
-        tPtrTextureData_D0.pType_0->buff_68[r2_i * 5 + 4] =
-            *[r6_pb + (uchar)r0_i1 + 0x30];
+        tPtrTextureData_D0.pType_0->buff_68[r2_i][0] = *(r6_pb + (uchar)i_sp40);
+        tPtrTextureData_D0.pType_0->buff_68[r2_i][1] =
+            *(r6_pb + (uchar)r10_i + 0xC);
+        tPtrTextureData_D0.pType_0->buff_68[r2_i][2] =
+            *(r6_pb + (uchar)r5_i + 0x18);
+        tPtrTextureData_D0.pType_0->buff_68[r2_i][3] =
+            *(r6_pb + (uchar)r0_i + 0x24);
+        tPtrTextureData_D0.pType_0->buff_68[r2_i][4] =
+            *(r6_pb + (uchar)r0_i1 + 0x30);
       }
       // 0019D12C
       // sp48=byte_2FDF94
@@ -491,47 +581,1275 @@ void CGfxCrowd::UpdateCrowdTextures(uint r1_u) {
       for (int r9_i = 0; r9_i != 0x20; r9_i++) {
         // 0019D146
         // loc_19D1D0
-        //这个循环数据结构不清晰暂时不处理
-        for (int r5_i = 0; r5_i != 0x20; r5_i++) {
+        for (int r5_i = 0; r5_i != 0x10; r5_i++) {
           // loc_19D14A
-          //check 寻址
-          tPtrTextureData_D0.pType_0->field_10c[r5_i].b_0 =
-              tPtrTextureData_D0.pType_0->buff_68[r9_i * 5 + byte_2FDF94[r5_i]];
-          char r0_b=GetAnim( tPtrTextureData_D0.pType_0->field_10c[r5_i].b_0)->filed_4;
+          tPtrTextureData_D0.pType_0->field_10c[r9_i][r5_i].b_0 =
+              tPtrTextureData_D0.pType_0->buff_68[r9_i][byte_2FDF94[r5_i]];
+          ushort r0_us =
+              GetAnim(tPtrTextureData_D0.pType_0->field_10c[r9_i][r5_i].b_0)
+                  ->filed_4;
           int r0_i;
-          if(r5_i==t_4630e0.byte_4630E0[byte_2FDF94[r5_i]*2]){
-            //0019D17A
-            //check UXTH
-           r0_i=  XSYS_RandomNoSync(r0_b);
-          }else{//loc_19D182
-
+          int r6_i = t_4630e0.byte_4630E0[byte_2FDF94[r5_i] * 2];
+          if (r5_i == r6_i) {
+            // 0019D17A
+            // check UXTH
+            r0_i = XSYS_RandomNoSync((ushort)r0_us);
+          } else {  // loc_19D182
+            float s0_f = t_4630e0.byte_4630E0[byte_2FDF94[r5_i * 2] + 1] - r6_i;
+            float s2_f = r5_i - r6_i;
+            s0_f = s2_f / s0_f;
+            // check UXTH
+            s2_f = r0_us;
+            // check 寻址 s4
+            float s4_f = tPtrTextureData_D0.pType_0->field_10c[r9_i][r6_i].us_2;
+            s4_f += s0_f * s2_f;
+            r0_i = (uint)s4_f % r0_us;
           }
-          //loc_19D1CA
-          tPtrTextureData_D0.pType_0->field_10c[r5_i].us_2=r0_i;
+          // loc_19D1CA
+          // check
+          tPtrTextureData_D0.pType_0->field_10c[r9_i][r5_i].us_2 = r0_i;
         }
-        //0019D1D4
+        // 0019D1D4
       }
+      
       break;
     }
     case 3:
     case 5: {
-      // loc_19D20E
-      //check 赋值
-     CFTTClearSettings clear_setting_sp120= g_tBlankCanvasClearSettings;
-     clear_setting_sp120.field_18=0xFFFFFF;
-     int r0_i=0;
-     if(r1_u!=3){
-       r0_i=1;
-     }
-     //sp40=tPtrTextureData_D0.pType_0[r0_i].texture_38
-     tPtrTextureData_D0.pType_0[r0_i].texture_38->BeginRenderToTexture(clear_setting_sp120);
-     //0019D24A
+      // loc_19D20E OK
+      // check 赋值
+      LOGE("case 3_5");
+      
+      CFTTClearSettings clear_setting_sp120 = g_tBlankCanvasClearSettings;
+      clear_setting_sp120.dRGBA_8 = 0xFFFFFF;
+      int r0_i = 0;
+      if (r1_u != 3) {
+        r0_i = 1;
+      }
+      // sp40=tPtrTextureData_D0.pType_0[r0_i].texture_38
+      tPtrTextureData_D0.pType_0
+          ->pprenderToTexture_38[r0_i]->BeginRenderToTexture(clear_setting_sp120);
+      // 0019D24A
+      CFTTVector32 vector_sp50;
+      vector_sp50.float_0 = -7.19999981f;
+      vector_sp50.float_4 = -0.100000001f;
+      vector_sp50.float_8 = 0;
+      CFTTVector32 vector_sp114;
+      vector_sp114.float_0 = 7.19999981f;
+      vector_sp114.float_4 = 2.4000001f;
+      vector_sp114.float_8 = 20.0f;
+      CFTTCamera::SetOrthographic(1.0f, 20.0f, 2.4000001f, -0.100000001f,
+                                  -7.19999981, 7.19999981f);
+      CFTTVector32 vector32_spD0;
+      vector32_spD0.float_0 = 0;
+      vector32_spD0.float_4 = 0;
+      vector32_spD0.float_8 = -10.0f;
+      CFTTCamera::SetPosition(vector32_spD0);
+      vector32_spD0.float_0 = 0;
+      vector32_spD0.float_4 = 0;
+      vector32_spD0.float_8 = 1.0f;
+      CFTTCamera::SetDirection(vector32_spD0, NULL);
+      CFTTCamera::SetViewport(0x400, 0x400, 0);
+      CFTTCamera::ApplyCameraSettings();
+      g_pGraphicsDevice->setDepthTest(EFTTDepthTest_8, true);
+      CFTTShaderBuiltInConstants::SetViewMatrix(CFTTMatrix32::s_matIdentity);
+      CFTTShaderBuiltInConstants::SetProjMatrix(CFTTMatrix32::s_matIdentity);
+      // 0019D2C6
+      // sp3c=GFXPLAYER_pBatch
+      GFXPLAYER_pBatch->cfttbmmmatrixcache_0.field_20 = false;
+      GFXPLAYER_pBatch->Begin();
+      // sp48=r11
+      // sp44=g_pGraphicsDevice
+      // s18=-1.0f
+      // s20=1.0f r10=0 r6=0xaf0 s16=0.0625f
+     
+      // loc_19D41E
+      for (int r10_i = 0; r10_i != 0x20; r10_i++) {
+        // loc_19D2F4
+        // loc_19D40C
+        for (int r4_i = 0; r4_i != 0x10; r4_i++) {
+          // loc_19D348
+          // tPtrTextureData_D0
+          float s22_f = (float)r4_i * 0.0625f;
+          float s24_f = (float)(r4_i + 1) * 0.0625f;
+          if (g_pGraphicsDevice->Matrices_FlipsRTT() == 0) {
+            // 0019D36E
+            if (g_pGraphicsDevice->Matrices_FlipsY() == 0) {
+              s24_f = 1.0f - s24_f;
+              s22_f = 1.0f - s22_f;
+            }
+          }
+        
+          // loc_19D380
+          float s2_f = s22_f + s22_f - 1.0f;
+          float s0_f = s24_f + s24_f - 1.0f;
+          // spc4=
+          // vector_sp50
+          CFTTMatrix32 matrix32_spd0;
+          CFTTVector32 vector32_spc4;
+
+          vector32_spc4.float_0 = -1.0f;
+          vector32_spc4.float_8 = 0;
+          CFTTVector32 vector32_spb8;
+          vector32_spb8.float_0 = 1.0f;
+          vector32_spb8.float_4 = s2_f;
+          vector32_spb8.float_8 = 1.0f;
+          vector32_spc4.float_4 = s0_f;
 
+          sub_19ED8C(matrix32_spd0, &vector_sp50, &vector_sp114, &vector32_spc4,
+                     &vector32_spb8);
+          // 0019D3BC
+          TSATAnim_TSX *r9_panim =
+              GetAnim(tPtrTextureData_D0.pType_0->field_10c[r10_i][r4_i].b_0);
+
+          TSATAnim_TSX *r3_panim = GetLegAnim(
+              tPtrTextureData_D0.pType_0->field_10c[r10_i][r4_i].b_0);
+          CFTTMatrix32 matrix_sp78 =
+              tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r10_i].Animate(
+                  r9_panim, r3_panim,
+                  tPtrTextureData_D0.pType_0->field_10c[r10_i][r4_i].us_2);
+          // 0019D3EE
+        
+          MatrixMultiply(&matrix_sp78, &matrix32_spd0, &CFTTCamera::s_matView);
+         
+          tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r10_i].Render(
+              &matrix_sp78);
+        
+        }
+        // 0019D410
+      }
+     
+      // 0019D426
+      GFXPLAYER_pBatch->End();
+      CGfxPlayer::FlushPlayerSkins();
+      GFXPLAYER_pBatch->ResetCache(false);
+      GFXPLAYER_pBatch->cfttbmmmatrixcache_0.field_20 = true;
+      // check ptype0
+      tPtrTextureData_D0.pType_0->pprenderToTexture_38[r0_i]->EndRenderToTexture(
+          EFTTRTTCopyMode_0);
+      
+      break;
     }
+    case 6: {
+      // 0019D470 OK
+      // r8=tPtrTextureData_D0
+      LOGE("case 6");
+      CFTTRenderToTexture *r11_prenderToTexture =
+          g_pGraphicsDevice->createRenderToTexture(
+              EFTTTexFormat_2, 0x200, 0x400, 1, 0, EFTTRTTZBufMode_1, false,
+              EFTTTextureType_0, 1);
+      // 0019D49E
+      CFTTRenderToTexture *prenderToTexture_sp48 =
+          g_pGraphicsDevice->createRenderToTexture(
+              EFTTTexFormat_2, 0x200, 0x400, 1, 0, EFTTRTTZBufMode_1, false,
+              EFTTTextureType_0, 1);
+      // 0019D4C2
+      CFTTRenderToTexture *prenderToTexture_sp44 =
+          g_pGraphicsDevice->createRenderToTexture(
+              EFTTTexFormat_2, 0x200, 0x400, 1, 0, EFTTRTTZBufMode_1, false,
+              EFTTTextureType_0, 1);
+      // 0019D4E4
+      r11_prenderToTexture->BeginRenderToTexture(g_tBlankCanvasClearSettings);
+      FTT2D_Begin();
+      // 0019D4FA
+      FTT2D_SetDefaultMatBlend(EFTT2D_Blend_5);
+      FTT2D_SetTexture(
+          tPtrTextureData_D0.pType_0->pprenderToTexture_38[0]->GetTexture(), 0);
+      // 0019D51A
+      FTT2D_DrawTexturedRect(0, 0, 512.0f, 512.0f, -1, 0, -999999.0f,
+                             -999999.0f);
+      // 0019D53C
+      FTT2D_SetTexture(
+          tPtrTextureData_D0.pType_0->pprenderToTexture_38[1]->GetTexture(), 0);
+      FTT2D_DrawTexturedRect(0, 512.0f, 512.0f, 512.0f, -1, 0, -999999.0f,
+                             -999999.0f);
+      FTT2D_End();
+      r11_prenderToTexture->EndRenderToTexture(EFTTRTTCopyMode_0);
+      CFTTVector32x4 vector32x4_spd0;
+      vector32x4_spd0.my[0] = 1.0f;
+      vector32x4_spd0.my[1] = 1.0f;
+      vector32x4_spd0.my[2] = 1.0f;
+      vector32x4_spd0.my[3] = 0;
+      CGaussianNewShader::s_tInstance.SetColourMultiplier(vector32x4_spd0);
+      // 0019D58C
+      GaussianBlur(
+          r11_prenderToTexture, prenderToTexture_sp44, prenderToTexture_sp48,
+          2.0f, tPtrTextureData_D0.pType_0->miCFTTMaterialIndex_0, true, true);
+      FTT2D_Begin();
+      FTT2D_SetDefaultMatBlend(EFTT2D_Blend_5);
+      // 0019D5B0
+      // sp3c=r11
+      FTT2D_SetTexture(r11_prenderToTexture->GetTexture(), 0);
+      // 0019D5C2
+      FTT2D_DrawTexturedRect(0, 0, 512.0f, 1024.0f, -1, 0, -999999.0f,
+                             -999999.0f);
+      FTT2D_SetDefaultMatBlend(EFTT2D_Blend_7);
 
-    default:
+      for (int r6_i = 0; r6_i != 0x20; r6_i++) {
+        // loc_19D5E2
+        FTT2D_DrawRect4(0, r6_i * 0x20, 512.0f, 32.0f, -1, -1, 0xFF404040,
+                        0xFF404040, 0, -999999.0f, -999999.0f);
+      }
+      // 0019D612
+      FTT2D_End();
+      //这里check r5_ptexture ptexture_9C的类型
+      CFTTTexture *r5_ptexture =
+          prenderToTexture_sp44->EndRenderToTexture(EFTTRTTCopyMode_2);
+      if (ptexture_9C) {  // 0019D62C
+        delete ptexture_9C;
+      }
+      // loc_19D632
+      ptexture_9C = r5_ptexture;
+
+      switch (GFXSPEC_pSpecification->eCrowdQuality_4C) {
+        case 2:
+        case 3:
+        case 4:
+          // loc_19D654
+          r5_ptexture->SetMinFilter(EFTTTex_MinFilter_5);
+          break;
+
+        case 1:
+        default:
+          r5_ptexture->SetMinFilter(EFTTTex_MinFilter_4);
+          // 0019D65A
+          break;
+      }
+      // 0019D664
+      CFTTTexParam parm;
+      // check 这里传参
+      parm.setTexture(ptexture_9C);
+
+      CCrowdNewShader::s_tInstance.SetDiffuse(parm, dCrowdNewShaderID_CBBC[0]);
+      if (tPtrTextureData_D0.pType_0->pprenderToTexture_38[0]) {
+        // 0019D688
+        delete tPtrTextureData_D0.pType_0->pprenderToTexture_38[0];
+      }
+      // loc_19D68E
+      tPtrTextureData_D0.pType_0->pprenderToTexture_38[0] = NULL;
+      if (tPtrTextureData_D0.pType_0->pprenderToTexture_38[1]) {
+        // 0019D6B0
+        delete tPtrTextureData_D0.pType_0->pprenderToTexture_38[1];
+      }
+      // loc_19D69E
+      tPtrTextureData_D0.pType_0->pprenderToTexture_38[1] = NULL;
+      delete prenderToTexture_sp44;
+      if (prenderToTexture_sp48) {
+        // 0019D6B0
+        delete prenderToTexture_sp48;
+      }
+      // loc_19D6B6
+      if (r11_prenderToTexture) {
+        delete r11_prenderToTexture;
+      }
+      // loc_19D6C0
+
+      break;
+    }
+    case 7: {
+      // 0019D724   OK
+      LOGE("case 7"); 
+      CFTTRenderToTexture *r4_prenderToTexture =
+          g_pGraphicsDevice->createRenderToTexture(
+              EFTTTexFormat_2, 0x100, 0x200, 0x1, 0x18, EFTTRTTZBufMode_1,
+              false, EFTTTextureType_0, 1);
+      if (tPtrTextureData_D0.pType_0->prenderToTexture_40) {
+        // 0019D758
+        delete tPtrTextureData_D0.pType_0->prenderToTexture_40;
+      }
+      // loc_19D75E
+      tPtrTextureData_D0.pType_0->prenderToTexture_40 = r4_prenderToTexture;
+      // s16=-1.5f r8=r0=0.0799999982f s18=-0.0399999991f r6=0xAE4
+      // loc_19D7AA
+      for (int r4_i = 0; r4_i != 4; r4_i++) {
+        // loc_19D776
+        float s0_f = XSYS_RandomNoSyncF(0.0799999982f);
+        float s2_f = (float)r4_i - 1.5f;
+        s0_f -= 0.0399999991f;
+        tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r4_i]
+            .m_cVec32_ADC.float_8 = 0;
+        tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r4_i]
+            .m_cVec32_ADC.float_4 = 0;
+        tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r4_i]
+            .m_cVec32_ADC.float_0 = s2_f + s0_f;
+      }
+      // 0019D7AE
+      CFTTClearSettings clearSetting_spd0 = g_tBlankCanvasClearSettings;
+      clearSetting_spd0.dRGBA_8 = 0xFFFFFF;
+      CGfxPlayer::SetupBatchConstants();
+      CPlayerShader::s_tInstance.SetShadowMap(EPlayerShader_ShadowMap_0);
+      CPlayerShader::s_tInstance.SetBlendMode(EPlayerShader_BlendMode_0);
+      CPlayerShader::s_tInstance.SetModel(EPlayerShader_Model_0);
+      CPlayerShader::s_tInstance.SetQuality(EPlayerShader_Quality_2);
+      tPtrTextureData_D0.pType_0->prenderToTexture_40->BeginRenderToTexture(
+          clearSetting_spd0);
+      tPtrTextureData_D0.pType_0->prenderToTexture_40->EndRenderToTexture(
+          EFTTRTTCopyMode_0);
+
+      break;
+    }
+    case 8: {  // loc_19D832 OK
+    LOGE("case 8");
+      for (int r4_i = 0; r4_i != 4; r4_i++) {
+        // loc_19D836
+        // check 寻址
+        tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r4_i].Setup(
+            ECrowdMemberType_2, 0xff);
+      }
+
+      // 0019D84E
+      FTTALG::Shuffle(tPtrTextureData_D0.pType_0->pmembers_34.pType_0,
+                      &tPtrTextureData_D0.pType_0->pmembers_34.pType_0[4]);
+      // loc_19D870
+      for (int r5_i = 0; r5_i != 4; r5_i++) {
+        uchar r0_b = XSYS_RandomNoSync(3);
+        tPtrTextureData_D0.pType_0->byte_108[r5_i] = byte_2FF0B7[r0_b];
+      }
+      // 0019D874
+      // sp44= tPtrTextureData_D0.pType_0->buff_90e
+      //r8=byte_2FF0C3
+      //r9=byte_4630E0
+      // loc_19D92A
+      for (int r1_i = 0; r1_i != 4; r1_i++) {
+        // loc_19D88A
+
+        // sp48=r1_i
+        for (int r6_i = 0; r6_i != 4; r6_i++) {
+          // loc_19D89C
+          // r1=byte_2FF0C3[r6_i]
+          // check
+          uint r4_u = t_4630e0.byte_4630E0[byte_2FF0C3[r6_i] * 2];
+          tPtrTextureData_D0.pType_0->data_90c[r1_i][r6_i].b_0 =
+              tPtrTextureData_D0.pType_0->byte_108[r1_i];
+          uint r5_u = t_4630e0.byte_4630E0[byte_2FF0C3[r6_i] * 2 + 1];
+          ushort r0_us =
+              GetAnim(tPtrTextureData_D0.pType_0->byte_108[r1_i])->filed_4;
+
+          if (r6_i == r4_u) {
+            // 0019D8BE
+            r0_us = XSYS_RandomNoSync(r0_us);
+          } else {
+            // loc_19D8C6
+            float s0_f = r5_u - r4_u;
+            float s2_f = r6_i - r4_u;
+            s0_f = s2_f / s0_f;
+            s2_f = r0_us;
+            float s4_f = tPtrTextureData_D0.pType_0->data_90c[r1_i][r4_u].us_2 +
+                         s0_f * s2_f;
+            r0_us = ((uint)s4_f) % r0_us;
+          }
+          // loc_19D912
+          tPtrTextureData_D0.pType_0->data_90c[r1_i][r6_i].us_2 = r0_us;
+        }
+      }
+
+      break;
+    }
+    case 9: {  // loc_19D94A OK
+       LOGE("case 9");
+      CFTTClearSettings clear_setting_sp78 = g_tBlankCanvasClearSettings;
+      clear_setting_sp78.dRGBA_8 = 0xFFFFFF;
+      tPtrTextureData_D0.pType_0->prenderToTexture_40->BeginRenderToTexture(
+          clear_setting_sp78);
+      //0019D978
+      CFTTVector32 vector_sp50;
+      vector_sp50.float_0 = -2.0f;
+      vector_sp50.float_4 = -0.100000001f;
+      vector_sp50.float_8 = 0;
+
+      CFTTVector32 vector_sp114;
+      vector_sp114.float_0 = 2.0f;
+      vector_sp114.float_4 = 3.0f;
+      vector_sp114.float_8 = 20.0f;
+
+      CFTTCamera::SetOrthographic(1.0f, 20.0f, 3.0f, -0.100000001f, -2.0f,
+                                  2.0f);
+      CFTTVector32 vector32_spd0;
+      vector32_spd0.float_0 = 0;
+      vector32_spd0.float_4 = 0;
+      vector32_spd0.float_8 = -10.0f;
+      CFTTCamera::SetPosition(vector32_spd0);
+      vector32_spd0.float_0 = 0;
+      vector32_spd0.float_4 = 0;
+      vector32_spd0.float_8 = 1.0f;
+      CFTTCamera::SetDirection(vector32_spd0, NULL);
+      CFTTCamera::SetViewport(0x100, 0x200, 0);
+      CFTTCamera::ApplyCameraSettings();
+      g_pGraphicsDevice->setDepthTest(EFTTDepthTest_8, true);
+
+      // s16=0.25f s18=-1.0f r9= tPtrTextureData_D0.pType_0->data_90c
+      // s20=1.0f r4=g_pGraphicsDevice R6=sp120
+      // sp44=g_pGraphicsDevice
+      // loc_19DB34
+      
+      for (int r5_i = 0; r5_i != 4; r5_i++) {
+        // loc_19DA00
+        float s0_f = (float)r5_i;
+        float s2_f = (float)(r5_i+1);
+        // check 虚函数顺序
+        float s24_f = s2_f * 0.25f;
+        float s22_f = s0_f * 0.25f;
+        if (g_pGraphicsDevice->Matrices_FlipsRTT() == 0) {
+          // 0019DA28
+          if (g_pGraphicsDevice->Matrices_FlipsY() == 0) {
+            s24_f = 1.0f - s24_f;
+            s22_f = 1.0f - s22_f;
+          }
+        }
+        // loc_19DA3A
+        s2_f = s22_f + s22_f;
+        s0_f = s24_f + s24_f;
+
+        CFTTMatrix32 mat32_spd0;
+        CFTTVector32 vector32_spc4;
+        CFTTVector32 vector32_spb8;
+        vector32_spc4.float_0 = -1.0f;
+        vector32_spc4.float_4 = s0_f - 1.0f;
+        vector32_spc4.float_8 = 0;
+
+        vector32_spb8.float_0 = 1.0f;
+        vector32_spb8.float_4 = s2_f - 1.0f;
+        vector32_spb8.float_8 = 1.0f;
+        // check mat32_spd0 是否是传出参数
+        sub_19ED8C(mat32_spd0, &vector_sp50, &vector_sp114, &vector32_spc4,
+                   &vector32_spb8);
+        CFTTShaderBuiltInConstants::SetProjMatrix(mat32_spd0);
+        GFXPLAYER_pBatch->Begin();
+        // loc_19DB12
+        for (int r10_i = 0; r10_i != 4; r10_i++) {
+          // loc_19DAD4
+          // check 寻址
+        
+          TSATAnim_TSX *r5_panim =
+              GetAnim(tPtrTextureData_D0.pType_0->data_90c[r10_i][r5_i].b_0);
+       
+          TSATAnim_TSX *r3_plegAnim =
+              GetLegAnim(tPtrTextureData_D0.pType_0->data_90c[r10_i][r5_i].b_0);
+         
+          CFTTMatrix32 mat32_sp120 =
+              tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r10_i].Animate(
+                  r5_panim, r3_plegAnim,
+                  tPtrTextureData_D0.pType_0->data_90c[r10_i][r5_i].us_2);
+          
+          tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r10_i].Render(NULL);
+       
+        }
+        // 0019DB18
+        GFXPLAYER_pBatch->End();
+        CGfxPlayer::FlushPlayerSkins();
+        GFXPLAYER_pBatch->ResetCache(false);
+      }
+      // 0019DB3A
+      tPtrTextureData_D0.pType_0->prenderToTexture_40->EndRenderToTexture(
+          EFTTRTTCopyMode_0);
+      LOGE("9 end");
+      break;
+    }
+    case 10: {
+      // loc_19DB64 OK
+      LOGE("case 10");
+      CFTTRenderToTexture *r11_prenderToTexture =
+          g_pGraphicsDevice->createRenderToTexture(EFTTTexFormat_2, 0x80, 0x100,
+                                                   0x1, 0, EFTTRTTZBufMode_1,
+                                                   false, EFTTTextureType_0, 1);
+      // 0019DB8E
+      // r10=r11
+      CFTTRenderToTexture *prenderToTexture_sp48 =
+          g_pGraphicsDevice->createRenderToTexture(EFTTTexFormat_2, 0x80, 0x100,
+                                                   0x1, 0, EFTTRTTZBufMode_1,
+                                                   false, EFTTTextureType_0, 1);
+      CFTTRenderToTexture *r9_prenderToTexture =
+          g_pGraphicsDevice->createRenderToTexture(EFTTTexFormat_2, 0x80, 0x100,
+                                                   0x1, 0, EFTTRTTZBufMode_1,
+                                                   false, EFTTTextureType_0, 1);
+      // 0019DBD2
+      r11_prenderToTexture->BeginRenderToTexture(g_tBlankCanvasClearSettings);
+      FTT2D_Begin();
+      FTT2D_SetDefaultMatBlend(EFTT2D_Blend_5);
+      FTT2D_SetTexture(
+          tPtrTextureData_D0.pType_0->prenderToTexture_40->GetTexture(), 0);
+      // 0019DBFC
+      FTT2D_DrawTexturedRect(0, 0, 128.0f, 256.0f, -1, 0, -999999.0f,
+                             -999999.0f);
+      FTT2D_End();
+      r11_prenderToTexture->EndRenderToTexture(EFTTRTTCopyMode_0);
+      // 0019DC2A
+      CFTTVector32x4 vector32x4_spd0;
+      vector32x4_spd0.my[0] = 1.0f;
+      vector32x4_spd0.my[1] = 1.0f;
+      vector32x4_spd0.my[2] = 1.0f;
+      vector32x4_spd0.my[3] = 0;
+
+      CGaussianNewShader::s_tInstance.SetColourMultiplier(vector32x4_spd0);
+      GaussianBlur(
+          r11_prenderToTexture, r9_prenderToTexture, prenderToTexture_sp48,
+          2.0f, tPtrTextureData_D0.pType_0->miCFTTMaterialIndex_0, true, true);
+      FTT2D_Begin();
+      FTT2D_SetDefaultMatBlend(EFTT2D_Blend_5);
+      FTT2D_SetTexture(r11_prenderToTexture->GetTexture(), 0);
+      FTT2D_DrawTexturedRect(0, 0, 128.0f, 256.0f, -1, 0, -999999.0f,
+                             -999999.0f);
+      FTT2D_End();
+      CFTTTexture *r5_ptexture =
+          r9_prenderToTexture->EndRenderToTexture(EFTTRTTCopyMode_2);
+      if (ptexture_A0) {  // 0019DCA8
+        delete ptexture_A0;
+      }
+      // loc_19DCAE
+      ptexture_A0 = r5_ptexture;
+      switch (GFXSPEC_pSpecification->eCrowdQuality_4C) {
+        case 2:
+        case 3:
+        case 4:
+          // loc_19DCD2
+          r5_ptexture->SetMinFilter(EFTTTex_MinFilter_5);
+          break;
+        default:
+          // 0019E904
+          r5_ptexture->SetMinFilter(EFTTTex_MinFilter_4);
+          // loc_19E908
+          break;
+      }
+      // 0019E90E
+      CFTTTexParam parm;
+      // check 这里传参
+      parm.setTexture(ptexture_A0);
+      LOGE("PARM.SIZE=%x",sizeof(parm));
+      
+      CCrowdNewShader::s_tInstance.SetDiffuse(parm, dCrowdNewShaderID_CBBC[1]);
+      if (tPtrTextureData_D0.pType_0->prenderToTexture_40) {
+        // 0019E930
+        delete tPtrTextureData_D0.pType_0->prenderToTexture_40;
+      }
+      // 0019E936
+      tPtrTextureData_D0.pType_0->prenderToTexture_40 = 0;
+      if (r9_prenderToTexture) {
+        // 0019E940
+        delete r9_prenderToTexture;
+      }
+      // loc_19E94A
+      if (prenderToTexture_sp48) {
+        delete prenderToTexture_sp48;
+      }
+      // loc_19E954
+      if (r11_prenderToTexture) {
+        // 0019E95C
+        delete r11_prenderToTexture;
+      }
+      break;
+    }
+    case 15: {
+      // loc_19E9C0 OK
+      //  check 虚函数
+      LOGE("case 15");
+      g_pGraphicsDevice->setDither(true);
+      FTT_pTex->ReleaseTexture(tPtrTextureData_D0.pType_0->texture_48);
+      FTT_pTex->ReleaseTexture(tPtrTextureData_D0.pType_0->texture_4C);
+      FTT_pTex->ReleaseTexture(tPtrTextureData_D0.pType_0->texture_50);
+      FTT_pTex->ReleaseTexture(tPtrTextureData_D0.pType_0->texture_58);
+      FTT_pTex->ReleaseTexture(tPtrTextureData_D0.pType_0->texture_4);
+      FTT_pTex->ReleaseTexture(tPtrTextureData_D0.pType_0->texture_8);
+      FTT_pTex->ReleaseTexture(tPtrTextureData_D0.pType_0->texture_C);
+      FTT_pTex->ReleaseTexture(tPtrTextureData_D0.pType_0->texture_10);
+      CModelManager::FreeModel(tPtrTextureData_D0.pType_0->model_2C);
+      CModelManager::FreeModel(tPtrTextureData_D0.pType_0->model_30);
+      FTT_pMtlL->ReleaseMaterial(
+          tPtrTextureData_D0.pType_0->miCFTTMaterialIndex_0);
+      tPtrTextureData_D0.pType_0->miCFTTMaterialIndex_0 = -1;
+      tPtrTextureData_D0 = NULL;
+      CPlayerShader::s_tInstance.SetCinematic(EPlayerShader_Cinematic_0);
+      CGfxEnvironmentMap::Get()->SetForced(EEnvMapOverride_0);
+      break;
+    }
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+     {
+      // check eCrowdQuality_4C
+      // 0019CBC0
+      LOGE("case default GFXSPEC_pSpecification->eCrowdQuality_4C=%x",GFXSPEC_pSpecification->eCrowdQuality_4C);
+      if (GFXSPEC_pSpecification->eCrowdQuality_4C) {
+        // 0019CBD0
+        // loc_19CF04
+        switch (r1_u) {
+          case 11: {
+            // loc_19DCDA
+            LOGE("case 11");
+            CFTTRenderToTexture *r4_prenderToTexture =
+                g_pGraphicsDevice->createRenderToTexture(
+                    EFTTTexFormat_2, 0x800, 0x800, 0x1, 0x18, EFTTRTTZBufMode_1,
+                    false, EFTTTextureType_0, 1);
+            // 0019DD0C
+            if (tPtrTextureData_D0.pType_0->prenderToTexture_44)  // 0019DD0E
+              delete tPtrTextureData_D0.pType_0->prenderToTexture_44;
+
+            tPtrTextureData_D0.pType_0->prenderToTexture_44 =
+                r4_prenderToTexture;
+            break;
+          }
+          case 12: {
+            // loc_19DD1C
+            LOGE("case 12");
+            for (uchar r5_uc = 0; r5_uc != 0x20; r5_uc++) {
+              // loc_19DD22
+              if (r5_uc <= 4) {
+                // 0019DD26
+                tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r5_uc].Setup(
+                    ECrowdMemberType_0, r5_uc);
+
+              } else {
+                // loc_19DD32
+                if (r5_uc <= 9) {
+                  // /0019DD3C
+                  tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r5_uc].Setup(
+                      ECrowdMemberType_1, r5_uc - 0x5);
+                } else {
+                  // loc_19DD44
+                  tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r5_uc].Setup(
+                      ECrowdMemberType_2, r5_uc - 0xa);
+                }
+              }
+            }
+            // 0019DD5A
+            for (int r1_i = 0; r1_i != 0x20; r1_i++) {
+              // loc_19DD60
+              tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r1_i]
+                  .m_cVec32_ADC.float_0 = 0;
+              tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r1_i]
+                  .m_cVec32_ADC.float_4 = 0;
+              tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r1_i]
+                  .m_cVec32_ADC.float_8 = 0;
+            }
+            // 0019DD7C
+            // sp48 dword_2FF0C8
+            // sp38=unk_2FF157
+            // r11=byte_2FF148
+            // loc_19DE22
+            for (int r9_i = 0; r9_i != 0x20; r9_i++) {
+              // loc_19DD9C
+              int r6_i = dword_2FF0C8[r9_i];
+              uchar r10_uc = XSYS_RandomNoSync(byte5_2FF148[r6_i].b_0);
+              uchar r4_uc = XSYS_RandomNoSync(byte5_2FF148[r6_i].b_1);
+              uchar r0_uc = XSYS_RandomNoSync(byte5_2FF148[r6_i].b_2);
+              const uchar *r5_puc = &byte_2FF157[r6_i * 60];
+
+              tPtrTextureData_D0.pType_0->buff_68[r9_i][1] =
+                  r5_puc[r4_uc + 0xc];
+              tPtrTextureData_D0.pType_0->buff_68[r9_i][0] = r5_puc[r10_uc];
+              tPtrTextureData_D0.pType_0->buff_68[r9_i][2] =
+                  r5_puc[r0_uc + 0x18];
+              r4_uc = XSYS_RandomNoSync(byte5_2FF148[r6_i].b_3);
+              r0_uc = XSYS_RandomNoSync(byte5_2FF148[r6_i].b_4);
+              tPtrTextureData_D0.pType_0->buff_68[r9_i][3] =
+                  r5_puc[r4_uc + 0x24];
+              tPtrTextureData_D0.pType_0->buff_68[r9_i][4] =
+                  r5_puc[r0_uc + 0x30];
+            }
+            // 0019DE28
+            // sp38=0 lr r8 r1
+            // r12=tPtrTextureData_D0
+            // r0 tPtrTextureData_D0.pType_0.2970
+            // loc_19DEDA
+            // check 寻址
+        
+            ushort us_sp38 = 0;
+            for (int r8_i = 0; r8_i != 0x20; r8_i++) {
+              // loc_19DE40
+              // r10 = tPtrTextureData_D0.pType_0->buf_2950[r8_i]
+              uchar r3_uc = 0;
+              int r9_i = dword_2FF0C8[r8_i];
+              tPtrTextureData_D0.pType_0->uc_2950[r8_i] = 0;
+              // loc_19DEC6
+              for (int r2_i = 0; r2_i != 5; r2_i++) {
+                // loc_19DE5A
+                if (byte_2FF157[r9_i * 5 + r2_i]) {
+                  // 0019DE66
+
+                  TGfxCrowdState::uSpan[r8_i][r2_i].b_0 = r3_uc;
+                  uchar r6_uc = dword_462764[tPtrTextureData_D0.pType_0
+                                                 ->buff_68[r8_i][r2_i]]
+                                    .filed_4;
+                  TGfxCrowdState::uSpan[r8_i][r2_i].b_1 = r6_uc + r3_uc;
+                  // check uxtab
+                  uint r1_u = r6_uc + r3_uc;
+                  // loc_19DEA0
+                  // check 这里
+                  while (r3_uc < r1_u) {
+                    // loc_19DE9C
+                    // check
+                    tPtrTextureData_D0.pType_0->buf_2970[r8_i][r3_uc] = r2_i;
+                    r3_uc++;
+                  }
+                  // 0019DEA4
+                  tPtrTextureData_D0.pType_0->uc_2950[r8_i] += r6_uc ;
+                  r3_uc=r1_u;
+                } else {
+                  // loc_19DEB2
+                  TGfxCrowdState::uSpan[r8_i][r2_i].b_0 = 0;
+                  TGfxCrowdState::uSpan[r8_i][r2_i].b_1 = 0;
+                }
+              }
+              // 0019DECA
+              us_sp38++;
+            }
+            // 0019DEE0
+            // r2=tPtrTextureData_D0.pType_0->buf_2970
+            // r11=tPtrTextureData_D0
+            // r10=tPtrTextureData_D0.pType_0.94e
+            // sp40=TGfxCrowdState::uSpan
+            // loc_19E092
+            for (int r5_i = 0; r5_i != 0x20; r5_i++) {
+              // loc_19DF34
+              // sp48=tPtrTextureData_D0.pType_0->buf_2950[r5_i]
+              // sp34=r10=tPtrTextureData_D0.pType_0.94e
+              // sp44=r2=tPtrTextureData_D0.pType_0->buf_2970
+              // loc_19DF4C
+              // r3=r10=tPtrTextureData_D0.pType_0.94e
+              for (int r9_u = 0;
+                   r9_u < tPtrTextureData_D0.pType_0->uc_2950[r5_i]; r9_u++) {
+                // 0019DF56
+                // check  寻址以及r4_uc
+                uchar r0_uc = tPtrTextureData_D0.pType_0->buf_2970[r5_i][r9_u];
+                uchar r4_uc = tPtrTextureData_D0.pType_0->buff_68[r5_i][r0_uc];
+                tPtrTextureData_D0.pType_0->buff_94c[r5_i][r9_u].b_0 = r4_uc;
+
+                ushort r1_us = GetAnim(r4_uc)->filed_4;
+                uint r0_u;
+                if (TGfxCrowdState::uSpan[r5_i][r0_uc].b_0 == r9_u) {
+                  // 0019DF90
+                  // sp3c=tPtrTextureData_D0.pType_0.94e
+                  if ((dword_462764[r4_uc].filed_5 |
+                       dword_462764[r4_uc].filed_6) == 0) {
+                    // 0019DFAE
+                    if (dword_462764[r4_uc].filed_7 == 0) {
+                      // 0019DFB2
+                      if (dword_462764[r4_uc].filed_8) {
+                        // loc_19DFBA
+                        r0_u =
+                            XSYS_RandomNoSync(1 - dword_462764[r4_uc].filed_5);
+                      } else {
+                        // loc_19E05A
+                        // check continue
+                        int r10_i = XSYS_RandomNoSync(r1_us);
+                        tPtrTextureData_D0.pType_0->buff_94c[r5_i][r9_u].us_2 =
+                            r10_i;
+                        r10_i += XSYS_RandomNoSync(r1_us);
+                        tPtrTextureData_D0.pType_0
+                            ->buff_94c[r5_i]
+                                      [TGfxCrowdState::uSpan[r5_i][r0_uc].b_1]
+                            .us_2 = r10_i;
+                        continue;
+                      }
+                    } else {
+                      // loc_19DFBA
+                      r0_u = XSYS_RandomNoSync(1 - dword_462764[r4_uc].filed_5);
+                      // 0019DFC6
+                    }
+
+                  } else {
+                    // loc_19DFBC
+                    r0_u = XSYS_RandomNoSync(dword_462764[r4_uc].filed_6 +
+                                             (1 - dword_462764[r4_uc].filed_5));
+                    // 0019DFC6
+                  }
+                  // 0019DFC6
+                  // check
+                  tPtrTextureData_D0.pType_0->buff_94c[r5_i][r9_u].us_2 =
+                      r0_u + dword_462764[r4_uc].filed_5;
+                  // check
+                  r0_u = XSYS_RandomNoSync(dword_462764[r4_uc].filed_8 +
+                                           (1 - dword_462764[r4_uc].filed_7));
+                  tPtrTextureData_D0.pType_0
+                      ->buff_94c[r5_i][TGfxCrowdState::uSpan[r5_i][r0_uc].b_1]
+                      .us_2 = r0_u + dword_462764[r4_uc].filed_7;
+
+                } else {
+                  // loc_19DFF4
+                  float s0_f = TGfxCrowdState::uSpan[r5_i][r0_uc].b_1 -
+                               TGfxCrowdState::uSpan[r5_i][r0_uc].b_0;
+                  float s2_f = r9_u - TGfxCrowdState::uSpan[r5_i][r0_uc].b_0;
+                  ushort r2_us =
+                      tPtrTextureData_D0.pType_0
+                          ->buff_94c[r5_i]
+                                    [TGfxCrowdState::uSpan[r5_i][r0_uc].b_0]
+                          .us_2;
+                  ushort r0_us =
+                      tPtrTextureData_D0.pType_0
+                          ->buff_94c[r5_i]
+                                    [TGfxCrowdState::uSpan[r5_i][r0_uc].b_1]
+                          .us_2;
+                  // check 这里一堆的数据类型转换
+                  float s4_f = r2_us;
+                  s0_f = s2_f / s0_f;
+                  s2_f = r0_us - r2_us;
+                  s4_f = s4_f + s0_f * s2_f;
+                  // check 取余函数 以及寻址
+                  tPtrTextureData_D0.pType_0->buff_94c[r5_i][r9_u].us_2 =
+                      (uint)s4_f % r1_us;
+                }
+                // loc_19E052
+              }
+              // loc_19E086
+            }
+            // 0019E098
+            // check uxth
+            // uint u_sp34=(ushort)us_sp38;
+            FTTVector<TShot> vectoeShot_sp78;
+            vectoeShot_sp78.Resize(us_sp38);
+            // r5=tPtrTextureData_D0.pType_0.94c
+            // r10=f4
+            // loc_19E192
+            // r2=0
+            uint r2_u = 0;
+            for (int r0_i = 0; r0_i != 0x20; r0_i++) {
+              // loc_19E0C4
+              // sp44=tPtrTextureData_D0.pType_0->buf_2950[r0_i]
+              // sp38=r5=tPtrTextureData_D0.pType_0.94c
+              // sp3c=r10=tPtrTextureData_D0.pType_0.f4
+              // uint r8_u=r2_u;
+              for (uint r11_u = 0;
+                   r11_u < tPtrTextureData_D0.pType_0->uc_2950[r0_i]; r11_u++) {
+                /// loc_19E0DE
+                // sp48=r2
+                // check 94c 寻址
+                TSATAnim_TSX *r4_panim =
+                    GetAnim(tPtrTextureData_D0.pType_0->buff_94c[r0_i][r11_u].b_0);
+                TSATAnim_TSX *r3_plegAnim = GetLegAnim(
+                    tPtrTextureData_D0.pType_0->buff_94c[r0_i][r11_u].b_0);
+                CFTTMatrix32 mat_spd0 =
+                    tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r0_i]
+                        .Animate(
+                            r4_panim, r3_plegAnim,
+                            tPtrTextureData_D0.pType_0->buff_94c[r0_i][r11_u].us_2);
+                // 0019E10E
+                CFTTVector32 vector32_sp120;
+                vector32_sp120.float_0 = 0.100000001f;
+                vector32_sp120.float_4 = 0.150000006f;
+                vector32_sp120.float_8 = 0.100000001f;
+                // CFTTMatrix32 结构体应该是包含TAABB结构 这里先不改
+                ((TAABB *)&mat_spd0)->Inflate(vector32_sp120);
+                data_d8[r0_i][r11_u].f_0 = mat_spd0.d[0][0];
+                data_d8[r0_i][r11_u].f_4 = mat_spd0.d[0][1];
+                // check
+                data_d8[r0_i][r11_u].f_8 = mat_spd0.d[0][3];
+                data_d8[r0_i][r11_u].f_C = mat_spd0.d[0][1];
+                data_d8[r0_i][r11_u].f_10 = mat_spd0.d[0][0];
+                data_d8[r0_i][r11_u].f_1C = mat_spd0.d[1][0];
+                data_d8[r0_i][r11_u].f_14 = mat_spd0.d[1][0];
+                data_d8[r0_i][r11_u].f_18 = mat_spd0.d[0][3];
+                vectoeShot_sp78.list_0[r2_u].b_0 = r11_u;
+                vectoeShot_sp78.list_0[r2_u].b_1 = r0_i;
+                vectoeShot_sp78.list_0[r2_u].f_4 = mat_spd0.d[0][0];
+                vectoeShot_sp78.list_0[r2_u].f_8 = mat_spd0.d[0][1];
+                vectoeShot_sp78.list_0[r2_u].f_C = mat_spd0.d[0][2];
+                vectoeShot_sp78.list_0[r2_u].f_10 = mat_spd0.d[0][3];
+
+                vectoeShot_sp78.list_0[r2_u].f_14 = mat_spd0.d[1][0];
+                vectoeShot_sp78.list_0[r2_u].f_18 = mat_spd0.d[1][1];
+                //vectoeShot_sp78
+
+                r2_u++;
+              }
+              // 0019E17E
+            }
+            // 0019E196
+            FTTVector<TShot>::Iterator vectorIt_sp70;
+            vectorIt_sp70.list_4 = vectoeShot_sp78.list_0;
+            FTTVector<TShot>::Iterator vectorIt_sp68;
+            vectorIt_sp68.list_4 =
+                vectoeShot_sp78.use_count_C + vectoeShot_sp78.list_0;
+            // check 函数符号以及传参是否使用了栈
+            
+            FTTALG::Quicksort<SortShots,FTTVector<TShot>::Iterator>(vectorIt_sp70, vectorIt_sp68);
+
+            FTTAtlasGenerator *r6_pGenerator =
+                new FTTAtlasGenerator(0x800, 0x800, 0x800);
+            tPtrTextureData_D0.pType_0->mpFTTAtlasGenerator_194C =
+                r6_pGenerator;
+     
+            float s16_f = us_sp38;
+            float s18_f = 80.0f;
+            // S20=0.25f s22=-10.0f s18=80.0f  s24=0.5f s19=0.00048828125f
+            // r0=1950 s26=-5.0f s28=0.75f s30=-1.0f s17=-2.0f
+            // r5 r10 =0
+            // r9=tPtrTextureData_D0.pType_0.1950
+            // for(uint r10_u=0;r10_u<u_sp34;)
+
+            // loc_19E21C
+            uint r5_u = 0;
+            int r10_i = 0;
+            // loc_19E2EA check 符号
+            while (r10_i < us_sp38) {
+              // 0019E2F0
+              int r1_i = s18_f * (vectoeShot_sp78.list_0[r5_u].f_10 -
+                                  vectoeShot_sp78.list_0[r5_u].f_4);
+              int r2_i = s18_f * (vectoeShot_sp78.list_0[r5_u].f_14 -
+                                  vectoeShot_sp78.list_0[r5_u].f_8);
+              FTTAtlasGeneratorNode *r0_node =
+                  tPtrTextureData_D0.pType_0->mpFTTAtlasGenerator_194C.pType_0
+                      ->Insert(r1_i, r2_i);
+              // 0019E32C check
+              tPtrTextureData_D0.pType_0
+                  ->buf_1950[vectoeShot_sp78.list_0[r5_u].b_1]
+                            [vectoeShot_sp78.list_0[r5_u].b_0] = r0_node;
+
+              if (tPtrTextureData_D0.pType_0
+                      ->buf_1950[vectoeShot_sp78.list_0[r5_u].b_1]
+                                [vectoeShot_sp78.list_0[r5_u].b_0] == 0) {
+                // 0019E34A
+                tPtrTextureData_D0.pType_0->mpFTTAtlasGenerator_194C.pType_0
+                    ->Clear();
+                float s0_f = (float)r10_i / s16_f;
+                float s2_f = -10.0f;
+                if (s0_f >= 0.25f) {
+                  // 0019E36C
+                  s2_f =  -5.0f;
+                  if (s0_f >= 0.5f) {
+                    // 0019E37A
+                    s2_f =  - 1.0f;
+                    if (s0_f < 0.75f) {
+                      s2_f =  - 2.0f;
+                    }
+                  }
+                }
+                // loc_19E38C
+                s18_f += s2_f;
+              } else {
+                // loc_19E23C
+                int r3_i = tPtrTextureData_D0.pType_0
+                               ->buf_1950[vectoeShot_sp78.list_0[r5_u].b_1]
+                                         [vectoeShot_sp78.list_0[r5_u].b_0]
+                               ->field_C;
+                int r12_i = tPtrTextureData_D0.pType_0
+                                ->buf_1950[vectoeShot_sp78.list_0[r5_u].b_1]
+                                          [vectoeShot_sp78.list_0[r5_u].b_0]
+                                ->field_10;
+                int lr_i = tPtrTextureData_D0.pType_0
+                               ->buf_1950[vectoeShot_sp78.list_0[r5_u].b_1]
+                                         [vectoeShot_sp78.list_0[r5_u].b_0]
+                               ->field_14;
+                int r11_i = tPtrTextureData_D0.pType_0
+                                ->buf_1950[vectoeShot_sp78.list_0[r5_u].b_1]
+                                          [vectoeShot_sp78.list_0[r5_u].b_0]
+                                ->field_18;
+                data_d8[vectoeShot_sp78.list_0[r5_u].b_1]
+                       [vectoeShot_sp78.list_0[r5_u].b_0]
+                           .f_20 = (float)r3_i * 0.00048828125f;
+
+                data_d8[vectoeShot_sp78.list_0[r5_u].b_1]
+                       [vectoeShot_sp78.list_0[r5_u].b_0]
+                           .f_24 = (float)(r3_i + lr_i) * 0.00048828125f;
+                data_d8[vectoeShot_sp78.list_0[r5_u].b_1]
+                       [vectoeShot_sp78.list_0[r5_u].b_0]
+                           .f_28 = (float)r2_i * 0.00048828125f;
+                data_d8[vectoeShot_sp78.list_0[r5_u].b_1]
+                       [vectoeShot_sp78.list_0[r5_u].b_0]
+                           .f_2C = (float)(r12_i + r11_i + 4) * 0.00048828125f;
+
+                r10_i++;
+                r5_u++;
+                continue;
+              }
+              // loc_19E21C
+              r5_u = 0;
+              r10_i = 0;
+            }
+
+            break;
+          }
+          case 13: {
+            // loc_19E3B0
+            LOGE("case 13");
+            CFTTClearSettings clearSetting_sp120 = g_tBlankCanvasClearSettings;
+            clearSetting_sp120.dRGBA_8 = 0xFFFFFF;
+            tPtrTextureData_D0.pType_0->prenderToTexture_44
+                ->BeginRenderToTexture(clearSetting_sp120);
+            // 0019E3EC
+            CFTTCamera::SetOrthographic(1.0f, 20.0f, 2.0f, 0, -1.0f, 1.0f);
+            CFTTVector32 vector32_spd0;
+            vector32_spd0.float_0 = 0;
+            vector32_spd0.float_4 = 0;
+            vector32_spd0.float_8 = -10.0f;
+            CFTTCamera::SetPosition(vector32_spd0);
+            vector32_spd0.float_0 = 0;
+            vector32_spd0.float_4 = 0;
+            vector32_spd0.float_8 = 1.0f;
+            CFTTCamera::SetDirection(vector32_spd0, 0);
+            CFTTCamera::SetViewport(0x800, 0x800, 0);
+            CFTTCamera::ApplyCameraSettings();
+            g_pGraphicsDevice->setDepthTest(EFTTDepthTest_8, true);
+            // s18=1.0f r6=sp50 s20=-1.0f s16=0.00048828125f
+            // r5=r11=tPtrTextureData_D0.pType_0
+            // sp44=sp5c
+            // sp3c=GFXPLAYER_pBatch
+            // loc_19E5DE
+            for (int r9_i = 0; r9_i != 0x20; r9_i++) {
+              // loc_19E46A
+
+              GFXPLAYER_pBatch->Begin();
+              // r5=tPtrTextureData_D0.pType_0->buff_94c[r9_i]
+              for (int r8_u = 0; tPtrTextureData_D0.pType_0->uc_2950[r9_i];
+                   r8_u++) {
+                // loc_19E484
+                TSATAnim_TSX *r4_panim = GetAnim(
+                    tPtrTextureData_D0.pType_0->buff_94c[r9_i][r8_u].b_0);
+                TSATAnim_TSX *r3_panim = GetLegAnim(
+                    tPtrTextureData_D0.pType_0->buff_94c[r9_i][r8_u].b_0);
+
+                CFTTMatrix32 mat_sp50 =
+                    tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r9_i]
+                        .Animate(
+                            r4_panim, r3_panim,
+                            tPtrTextureData_D0.pType_0->buff_94c[r9_i][r8_u]
+                                .us_2);
+                vector32_spd0.float_0 = 0.100000001f;
+                vector32_spd0.float_4 = 0.300000012f;
+                vector32_spd0.float_8 = 0.100000001f;
+                ((TAABB *)&mat_sp50)->Inflate(vector32_spd0);
+                // 0019E4C4
+                int r1_i =
+                    tPtrTextureData_D0.pType_0->buf_1950[r9_i][r8_u]->field_C;
+                int r2_i =
+                    tPtrTextureData_D0.pType_0->buf_1950[r9_i][r8_u]->field_10;
+                int r3_i =
+                    tPtrTextureData_D0.pType_0->buf_1950[r9_i][r8_u]->field_14;
+                int r0_i =
+                    tPtrTextureData_D0.pType_0->buf_1950[r9_i][r8_u]->field_18;
+                float s6_f = r1_i;
+                float s4_f = r2_i;
+                float s0_f = r0_i + r2_i;
+                float s2_f = r3_i + r1_i;
+                float s24_f = s0_f * 0.00048828125f;
+                float s22_f = s2_f * 0.00048828125f;
+                float s28_f = s4_f * 0.00048828125f;
+                float s26_f = s6_f * 0.00048828125f;
+               
+                if (g_pGraphicsDevice->Matrices_FlipsRTT() ||
+                    g_pGraphicsDevice->Matrices_FlipsY()) {
+                  // loc_19E51E
+                  s24_f = 1.0f - s24_f;
+                  s28_f = 1.0f - s28_f;
+                }
+                // loc_19E526
+                s4_f = s24_f + s24_f;
+                s6_f = s22_f + s22_f;
+                s0_f = s28_f + s28_f;
+                s2_f = s26_f + s26_f;
+                CFTTVector32 vector_sp114;
+                vector_sp114.float_8 = 0;
+                mat_sp50.d[0][2]=0;
+                mat_sp50.d[1][1]=20.0f;
+                // sp64= 20f
+                s4_f = s4_f - 1.0f;
+                s6_f = s6_f - 1.0f;
+                s0_f = s0_f - 1.0f;
+                s2_f = s2_f - 1.0f;
+
+                CFTTVector32 vector_spc4;
+                vector_spc4.float_0 = s6_f;
+                vector_spc4.float_4 = s4_f;
+                vector_spc4.float_8 = 1.0f;
+                vector_sp114.float_0 = s2_f;
+                vector_sp114.float_4 = s0_f;
+                CFTTMatrix32 mat32_spd0;
+                sub_19ED8C(mat32_spd0, (CFTTVector32 *)&mat_sp50,
+                           (CFTTVector32 *)&mat_sp50.d[0][3], &vector_sp114,
+                           &vector_spc4);
+                CFTTShaderBuiltInConstants::SetViewMatrix(
+                    CFTTMatrix32::s_matIdentity);
+                CFTTShaderBuiltInConstants::SetProjMatrix(
+                    CFTTMatrix32::s_matIdentity);
+                // 0019E58C
+                CFTTMatrix32 mat32_sp78;
+                MatrixMultiply(&mat32_sp78, &mat32_spd0,
+                               &CFTTCamera::s_matView);
+                tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r9_i].Render(
+                    &mat32_sp78);
+              }
+              // 0019E5BE
+              GFXPLAYER_pBatch->End();
+              CGfxPlayer::FlushPlayerSkins();
+              GFXPLAYER_pBatch->ResetCache(false);
+            }
+            // 0019E5E6
+            tPtrTextureData_D0.pType_0->prenderToTexture_44->EndRenderToTexture(
+                EFTTRTTCopyMode_0);
+            GFXPLAYER_pBatch->cfttbmmmatrixcache_0.field_20 = 1;
+            break;
+          }
+          case 14: {
+            // loc_19E602
+            LOGE("case 14");
+            CFTTRenderToTexture *r4_prenderToTexture =
+                g_pGraphicsDevice->createRenderToTexture(
+                    EFTTTexFormat_2, 0x400, 0x400, 0x1, 0, EFTTRTTZBufMode_1,
+                    false, EFTTTextureType_0, 1);
+
+            CFTTRenderToTexture *prenderToTexture_sp44 =
+                g_pGraphicsDevice->createRenderToTexture(
+                    EFTTTexFormat_2, 0x400, 0x400, 0x1, 0, EFTTRTTZBufMode_1,
+                    false, EFTTTextureType_0, 1);
+
+            CFTTRenderToTexture *r9_prenderToTexture =
+                g_pGraphicsDevice->createRenderToTexture(
+                    EFTTTexFormat_2, 0x400, 0x400, 0x1, 0, EFTTRTTZBufMode_1,
+                    false, EFTTTextureType_0, 1);
+
+            r4_prenderToTexture->BeginRenderToTexture(
+                g_tBlankCanvasClearSettings);
+            FTT2D_Begin();
+            FTT2D_SetDefaultMatBlend(EFTT2D_Blend_5);
+            FTT2D_SetTexture(
+                tPtrTextureData_D0.pType_0->prenderToTexture_44->GetTexture(),
+                0);
+            FTT2D_DrawTexturedRect(0, 0, 1024.0f, 1024.0f, -1, 0, -999999.0f,
+                                   -999999.0f);
+            FTT2D_End();
+            r4_prenderToTexture->EndRenderToTexture(EFTTRTTCopyMode_0);
+            // 0019E6CE
+            CFTTVector32x4 vector32x4_spd0;
+            vector32x4_spd0.my[0] = 1.0f;
+            vector32x4_spd0.my[1] = 1.0f;
+            vector32x4_spd0.my[2] = 1.0f;
+            vector32x4_spd0.my[3] = 0;
+            CGaussianNewShader::s_tInstance.SetColourMultiplier(
+                vector32x4_spd0);
+            // sp3c=r9
+            GaussianBlur(r4_prenderToTexture, r9_prenderToTexture,
+                         prenderToTexture_sp44, 2.0f,
+                         tPtrTextureData_D0.pType_0->miCFTTMaterialIndex_0,
+                         true, true);
+            FTT2D_Begin();
+
+            FTT2D_SetTexture(r4_prenderToTexture->GetTexture(), 0);
+            FTT2D_DrawTexturedRect(0, 0, 1024.0f, 1024.0f, -1, 0, -999999.0f,
+                                   -999999.0f);
+            FTT2D_SetDefaultMatBlend(EFTT2D_Blend_7);
+            // sp40=r4
+
+            // s16=2.5f s18=192.0f s20=64.0f s22=255.0f
+            // sp48=r11=tPtrTextureData_D0.pType_0
+            // loc_19E8B8
+
+            for (int r10_i = 0; r10_i != 0x20; r10_i++) {
+              // loc_19E754
+              // r8=tPtrTextureData_D0.pType_0.2950[r10_i]
+              for (uint r9_u = 0;
+                   r9_u < tPtrTextureData_D0.pType_0->uc_2950[r10_i]; r9_u++) {
+                // loc_19E7A8
+                TSATAnim_TSX *r5_panim = GetAnim(
+                    tPtrTextureData_D0.pType_0->buff_94c[r10_i][r9_u].b_0);
+                TSATAnim_TSX *r3_panim = GetLegAnim(
+                    tPtrTextureData_D0.pType_0->buff_94c[r10_i][r9_u].b_0);
+                CFTTMatrix32 mat32_spd0 =
+                    tPtrTextureData_D0.pType_0->pmembers_34.pType_0[r10_i]
+                        .Animate(
+                            r5_panim, r3_panim,
+                            tPtrTextureData_D0.pType_0->buff_94c[r10_i][r9_u]
+                                .us_2);
+                CFTTVector32 vector_sp78;
+                vector_sp78.float_0 = 0.100000001f;
+                vector_sp78.float_4 = 0.300000012f;
+                vector_sp78.float_8 = 0.100000001f;
+                ((TAABB *)&mat32_spd0)->Inflate(vector_sp78);
+                // 0019E7F2
+                float s0_f = mat32_spd0.d[1][0] / 2.5f;
+                int r0_i =
+                    tPtrTextureData_D0.pType_0->buf_1950[r10_i][r9_u]->field_C /
+                    2;
+                int r1_i =
+                    0x400 - tPtrTextureData_D0.pType_0->buf_1950[r10_i][r9_u]
+                                    ->field_10 /
+                                2;
+                int r2_i = tPtrTextureData_D0.pType_0->buf_1950[r10_i][r9_u]
+                               ->field_14 /
+                           2;
+                           //s8=r3
+                int r3_i = 0 - tPtrTextureData_D0.pType_0->buf_1950[r10_i][r9_u]
+                                       ->field_18 /
+                                   2;
+
+                float s10_f = 64.0f + s0_f * 192.0f;
+                float s2_f = r0_i;
+                float s8_f = r3_i;
+                float s4_f = r1_i;
+                float s6_f = r2_i;
+                s0_f = 255.0f;
+                if (s10_f < 255.0f) {
+                  s0_f = s10_f;
+                }
+
+                uint r5_u = s0_f;
+
+                r5_u =
+                    ((r5_u | (r5_u * 0x100)) | (r5_u * 0x10000)) | 0xFF000000;
+                FTT2D_DrawRect4(s2_f, s4_f, s6_f, s8_f, 0xFF404040, 0xFF404040,
+                                r5_u, r5_u, 0, -999999.0f, -999999.0f);
+              }
+              // 0019E8AA
+            }
+            // 0019E8C0
+            FTT2D_End();
+            CFTTTexture *r4_ptexture =
+                r9_prenderToTexture->EndRenderToTexture(EFTTRTTCopyMode_2);
+            if (ptexture_A4) {
+              // 0019E8DA
+              delete ptexture_A4;
+            }
+            // loc_19E8E0
+            ptexture_A4 = r4_ptexture;
+            switch (GFXSPEC_pSpecification->eCrowdQuality_4C) {
+              case 1:
+              case 2:
+              case 3:
+              case 4:
+                // loc_19E8FE
+
+                // loc_19E96C
+                r4_ptexture->SetMinFilter(EFTTTex_MinFilter_5);
+                break;
+
+              default:
+                // 0019E968
+                // loc_19E96C
+                r4_ptexture->SetMinFilter(EFTTTex_MinFilter_4);
+                break;
+            }
+            // 0019E972
+            CFTTTexParam parm;
+            // check 这里传参
+            parm.setTexture(ptexture_A4);
+
+            CCrowdNewShader::s_tInstance.SetDiffuse(parm,
+                                                    dCrowdNewShaderID_CBBC[2]);
+            if (tPtrTextureData_D0.pType_0->prenderToTexture_44) {
+              // 0019E994
+              delete tPtrTextureData_D0.pType_0->prenderToTexture_44;
+            }
+            // loc_19E99A
+            tPtrTextureData_D0.pType_0->prenderToTexture_44 = NULL;
+            delete r9_prenderToTexture;
+            // 0019E9A8
+            if (prenderToTexture_sp44)  // 0019E9AA
+              delete prenderToTexture_sp44;
+            // loc_19E9B0
+            if (r4_prenderToTexture)  // 0019E9B4
+              delete r4_prenderToTexture;
+            // loc_19E9BA
+            break;
+          }
+
+          default:
+            break;
+        }
+      }
       break;
+    }
+    default:
+    break;
   }
+  LOGE("end");
 }
 //-------------------------------------------------------------------------------------------------
 // 0019F7E4 ^_^

+ 49 - 16
jni/CGfxCrowd.h

@@ -1,7 +1,7 @@
 // CGfxCrowd - [2020-04-13 11:57:46]
 #ifndef _CGFXCROWD_H_
 #define _CGFXCROWD_H_
-
+#include "TGfxCrowdState.h"
 #include "CFTTModel.h"
 #include "FTTVector.h"
 #include "CStaticAABBTree.h"
@@ -10,10 +10,9 @@
 #include "TDrawCall.h"
 #include "CGfxCrowdCardGroup.h"
 #include "CGfxCrowdFlagRender.h"
-#include "TGfxCrowdState.h"
 #include "CFTTRenderToTexture.h"
 #include "TCrowd.h"
-
+//class TGfxCrowdState;
 /*
 0019691C CGfxCrowd::CGfxCrowd()
 00196A10 CGfxCrowd::~CGfxCrowd()
@@ -54,6 +53,24 @@ struct TGfxCrowdDynamic {
   int un_0;
 };
 
+
+struct TShot
+{
+  uchar b_0;
+  uchar b_1;
+  ushort field_2;
+  float f_4;
+  float f_8;
+  float f_C;
+  float f_10;
+  float f_14;
+  float f_18;
+};
+
+struct SortShots
+{
+  
+};
 /*
 Crowd 相关类, 重点检查 Anderson
 
@@ -67,7 +84,7 @@ CrowdTextureCreationData.cpp
 TCrowdMember.cpp
 TGfxCrowdState.cpp
 */
-
+class CrowdTextureCreationData;
 class CGfxCrowd {
 public:
   CGfxCrowd();                                         // 0019691C
@@ -105,9 +122,9 @@ public:
   FTTUPtr<CFTTRenderHelper> tUPtr_94;
   FTTUPtr<CFTTRenderHelper> tUPtr_98;
 
-  CFTTRenderToTexture *pRender2Tex_9C;
-  CFTTRenderToTexture *pRender2Tex_A0;
-  CFTTRenderToTexture *pRender2Tex_A4;
+  CFTTTexture *ptexture_9C;
+  CFTTTexture *ptexture_A0;
+  CFTTTexture *ptexture_A4;
 
   FTTVector<uint> vec_A8;
   FTTVector<TDrawCall> vec_BC;
@@ -115,23 +132,39 @@ public:
   FTTUPtr<CrowdTextureCreationData> tPtrTextureData_D0;
 
   int field_D4;
-  int field_D8;
 
-  uchar field_DC[0xBFF8];  //????????????????????????????????????????????????????? 未知
-
-  int field_C0D4;
+  struct CGfxCrowd_D8
+  {
+    float f_0;
+    float f_4;
+    float f_8;
+    float f_C;
+    float f_10;
+    float f_14;
+    float f_18;
+    float f_1C;
+    float f_20;
+    int f_24;
+    int f_28;
+    int f_2C;
+  }data_d8[0x20][0x20];
+  //int field_D8;
+
+  // uchar field_6D8[0xB9FC];  //????????????????????????????????????????????????????? 未知
+
+  // int field_C0D4;
 
   FTTVector<TGfxCrowdSection> vec_C0D8;
-
+  
   TGfxCrowdState tCrowd_C0EC[9];
   TGfxCrowdState tCrowd_C1A0[32][4];
 
   FTTVector<CStaticAABBTree<ushort, 16u>> vec_CBA0;
 
-  bool b_CBB4;
-  bool b_CBB5;
-  bool b_CBB6;
-  bool b_CBB7;
+  bool  b_CBB4;
+  bool  b_CBB5;
+  bool  b_CBB6;
+  bool  b_CBB7;
   float f_CBB8;
   uint dCrowdNewShaderID_CBBC[3];  // 00196A3C 此处可以确定是一个数组
   float f_CBC8[3];                 // 001A12FC

+ 3 - 1
jni/CGfxEnvironmentMap.cpp

@@ -126,6 +126,8 @@ EEnvMapOverride CGfxEnvironmentMap::GetForced() {
 }
 //-------------------------------------------------------------------------------------------------
 //001AE540
-void CGfxEnvironmentMap::SetForced(EEnvMapOverride) {
+void CGfxEnvironmentMap::SetForced(EEnvMapOverride a1) {
+  LOGE("%x",this);
+  LOGE("%x",a1);
 }
 //-------------------------------------------------------------------------------------------------

+ 7 - 2
jni/CGfxKits.cpp

@@ -37,7 +37,8 @@ CFTTTexture *CGfxKits::GetTexture(int &i0,
                                   int i2,
                                   EKitTextureType e3,
                                   CFTTTexLoadOptions const *pCFTTTexLoadOptions4) {
-  return nullptr;
+  LOGE("CGfxKits::GetTexture%x%x%x%x%x",i0,pTBuildKitTeamTextures1,i2,e3,pCFTTTexLoadOptions4);
+  return (CFTTTexture*)rand();
 }
 //-------------------------------------------------------------------------------------------------
 //00184AE8 ^_^
@@ -51,12 +52,14 @@ CFTTTexture *CGfxKits::BuildTexture(int &i0,
 //-------------------------------------------------------------------------------------------------
 //0018516C ^_^
 int CGfxKits::BeginBuildKit(int i0) {
-  return 1;
+  LOGE("CGfxKits::BeginBuildKit%x",i0);
+  return rand();
 }
 
 //-------------------------------------------------------------------------------------------------
 //00185184 ^_^
 void CGfxKits::EndBuildKit() {
+  LOGE("CGfxKits::EndBuildKit");
 }
 //-------------------------------------------------------------------------------------------------
 //001851A0 ^_^
@@ -65,10 +68,12 @@ void CGfxKits::EmptyKitTemplateCache() {
 //-------------------------------------------------------------------------------------------------
 //001851DC ^_^
 void CGfxKits::FreeKitTeamTextures(TBuildKitTeamTextures *pTBuildKitTeamTextures0) {
+  LOGE("CGfxKits::FreeKitTeamTextures%x",pTBuildKitTeamTextures0);
 }
 //-------------------------------------------------------------------------------------------------
 //0018521C ^_^
 void CGfxKits::LoadKitTeamTextures(CTeam *pCTeam0, TBuildKitTeamTextures *pTBuildKitTeamTextures1, CFTTTexLoadOptions const &pCFTTTexLoadOptions2, int i3) {
+LOGE("CGfxKits::LoadKitTeamTextures%x%x%x%x",pCTeam0,pTBuildKitTeamTextures1,pCFTTTexLoadOptions2,i3);
 }
 //-------------------------------------------------------------------------------------------------
 //0018529C ^_^ 要开栈保护编译

+ 3 - 0
jni/CGfxPlayer.cpp

@@ -73,10 +73,12 @@ void CGfxPlayer::ShutdownBatchManager() {
 //-------------------------------------------------------------------------------------------------
 //00186BD4
 void CGfxPlayer::SetupBatchConstants() {
+   LOGE("CGfxPlayer::SetupBatchConstants");
 }
 //-------------------------------------------------------------------------------------------------
 //00186D48
 void CGfxPlayer::InitPlayersGame() {
+  LOGE("CGfxPlayer::InitPlayersGame");
 }
 //-------------------------------------------------------------------------------------------------
 //00186F9C
@@ -106,6 +108,7 @@ void CGfxPlayer::RenderPlayerTranslucent(bool) {
 //-------------------------------------------------------------------------------------------------
 //00187598
 void CGfxPlayer::FlushPlayerSkins() {
+  LOGE("CGfxPlayer::FlushPlayerSkins");
 }
 //-------------------------------------------------------------------------------------------------
 //00187604

+ 6 - 2
jni/CModelManager.cpp

@@ -31,11 +31,15 @@ void CModelManager::CalculateBounds(CFTTModel *pModel) {
 //-------------------------------------------------------------------------------------------------
 //00185988 //^_- 经过单元测试,功能正常
 CFTTModel *CModelManager::LoadModel(char const *pFileName, char const *pDir, EModelLoadFlags eFlag, bool b) {
-  return 0;
+  LOGE("CModelManager::LoadModel%x%x%x%x",pFileName,pDir,eFlag,b);
+
+  return (CFTTModel*)rand();
 }
 //-------------------------------------------------------------------------------------------------
 //001859DC
-void CModelManager::FreeModel(CFTTModel *) {
+void CModelManager::FreeModel(CFTTModel *a1) {
+
+LOGE("%x",a1);
 }
 //-------------------------------------------------------------------------------------------------
 //00185A28

+ 2 - 1
jni/CPBRLighting.cpp

@@ -42,7 +42,7 @@ void CPBRLighting::Shutdown() {
 //-------------------------------------------------------------------------------------------------
 //0018C9C4
 CPBRLighting *CPBRLighting::Get() {
-  return nullptr;
+  return (CPBRLighting*)rand();
 }
 //-------------------------------------------------------------------------------------------------
 //0018CA14 -_- 经过单元测试,功能正常
@@ -93,6 +93,7 @@ void CPBRLighting::CreateGrassLUT() {
 //-------------------------------------------------------------------------------------------------
 //0018E154 ^_^
 void CPBRLighting::Reinitialise(bool b) {
+  LOGE("%x%x",this,b);
 }
 //-------------------------------------------------------------------------------------------------
 //0018E1AA

+ 19 - 0
jni/CPlayerShader.cpp

@@ -46,10 +46,15 @@ void CPlayerShader::SetSpecularEnv(CFTTTexParam aTexParam, int a2) {
 //-------------------------------------------------------------------------------------------------
 //0011FDBC //^_^
 void CPlayerShader::SetModel(EPlayerShader_Model eModel) {
+   LOGE("%x",this);
+LOGE("%x",eModel);
 }
+
 //-------------------------------------------------------------------------------------------------
 //0011FDCE //^_^
 void CPlayerShader::SetShadowMap(EPlayerShader_ShadowMap eShadowMap) {
+  LOGE("%x",this);
+LOGE("%x",eShadowMap);
 }
 //-------------------------------------------------------------------------------------------------
 //0011FDE0 //^_^
@@ -58,22 +63,36 @@ void CPlayerShader::SetLightDir(CFTTVector32 const& pVector32) {
 //-------------------------------------------------------------------------------------------------
 //0011FDEC //^_^
 void CPlayerShader::SetBlendMode(EPlayerShader_BlendMode eBlendMode) {
+  LOGE("%x",this);
+LOGE("%x",eBlendMode);
+
 }
 //-------------------------------------------------------------------------------------------------
 //001265B4 //^_^
 void CPlayerShader::SetCinematic(EPlayerShader_Cinematic eCinematic) {
+  LOGE("%x",this);
+LOGE("%x",eCinematic);
 }
 //-------------------------------------------------------------------------------------------------
 //001265C6 //^_^
 void CPlayerShader::SetCinematicLightingCloth(CFTTVector32x4 const& pVector32x4) {
+  LOGE("%x",this);
+  LOGE("%x",&pVector32x4);
+  LOGE("%x%x%x%x",pVector32x4.my[0],pVector32x4.my[1],pVector32x4.my[2],pVector32x4.my[3]);
 }
 //-------------------------------------------------------------------------------------------------
 //001265D2 //^_^
 void CPlayerShader::SetCinematicLightingSkin(CFTTVector32x4 const& pVector32x4) {
+  LOGE("%x",this);
+
+
+LOGE("%x%x%x%x",pVector32x4.my[0],pVector32x4.my[1],pVector32x4.my[2],pVector32x4.my[3]);
 }
 //-------------------------------------------------------------------------------------------------
 //001265DE //^_^
 void CPlayerShader::SetQuality(EPlayerShader_Quality eQuality) {
+  LOGE("%x",this);
+LOGE("%x",eQuality);
 }
 //-------------------------------------------------------------------------------------------------
 //0017F508 //^_^

+ 38 - 25
jni/CUITile.cpp

@@ -12,7 +12,13 @@
 #include "LOCstring.h"
 #include "CUITile.h"
 #include "CFTTTime.h"
-
+//00137F58 //^_^
+void CUITile::TileSetFont(int a1) {
+  srand(time(NULL));
+  int ret = rand();
+  printf("%d%x", ret, a1);
+  return;
+}
 //-------------------------------------------------------------------------------------------------
 //001294B2 //^_^
 TUITBText::TUITBText(wchar_t const *p_wc_r1_arg,
@@ -82,9 +88,7 @@ void CUITile::TileDrawShadowSmall(float f1, float f2, float f3, float f4) {
 }
 //-------------------------------------------------------------------------------------------------
 //00137EC2 //^_^ 经过单元测试,功能正常
-void CUITile::TileDrawTex(TImage *pImage1, float f2, float f3, float f4, float f5, uint u6) {
-  LOGI("CUITile::TileDrawTex 00137EC2 entry");
-}
+
 //-------------------------------------------------------------------------------------------------
 //00137F54
 void CUITile::RenderPost() {
@@ -92,18 +96,22 @@ void CUITile::RenderPost() {
 }
 //-------------------------------------------------------------------------------------------------
 //00137F58 //^_^
-void CUITile::TileSetFont(int a1) {
-  LOGI("CUITile::TileSetFont 00137F58 entry");
-}
+
 //-------------------------------------------------------------------------------------------------
 //00137F78  //^_^
-void CUITile::TileSetFontScale(float f1, float f2) {
-  LOGI("CUITile::TileSetFontScale 00137F78 entry");
+void CUITile::TileSetFontScale(float a1, float a2) {
+  srand(time(NULL));
+  int ret = rand();
+  printf("%d%x%x", ret, a1, a2);
+  return;
 }
 //-------------------------------------------------------------------------------------------------
 //00137FAE //^_^
 void CUITile::TileSetFontScaleForWidth(wchar_t const *pWbuf1, float f2) {
-  LOGI("CUITile::TileSetFontScaleForWidth 00137FAE entry");
+srand(time(NULL));
+  int ret = rand();
+   puts((char*)pWbuf1);
+  printf("%d%x", ret, f2);
 }
 //-------------------------------------------------------------------------------------------------
 //00137FC6 //^_^
@@ -125,16 +133,21 @@ TextDimensions CUITile::TileGetTextDims(wchar_t const *pWbuf1) {
 }
 //-------------------------------------------------------------------------------------------------
 //0013802A
-TextDimensions CUITile::TileGetTextDimsWrap(float f2, wchar_t const *pWbuf3) {
-  // TextDimensions tRet;
-  LOGI("CUITile::TileGetTextDimsWrap 0013802A entry");
-  TextDimensions tRet;
-  return tRet;
+TextDimensions CUITile::TileGetTextDimsWrap(float a2, wchar_t const* a1) {
+  srand(time(NULL));
+  int ret = rand();
+  printf("%d%x%x", ret, a1, a2);
+  TextDimensions ret1;
+  ret1.field_0=ret;
+  ret1.field_4=ret;
+  return ret1;
 }
 //-------------------------------------------------------------------------------------------------
 //0013806A //^_^
-void CUITile::TilePrint(float f1, float f2, wchar_t const *pWBuf3) {
-  LOGI("CUITile::TilePrint 0013806A entry");
+void CUITile::TilePrint(float a1, float a2, wchar_t const *pWBuf3) {
+  puts((char*)pWBuf3);
+  int ret = rand();
+  printf("%d%x%x", ret, a1, a2);
 }
 //-------------------------------------------------------------------------------------------------
 //001380AC //^_^
@@ -176,9 +189,7 @@ void CUITile::TilePrintWrapRotf(float f1, float f2, float f3, EFontWrapType eTyp
 }
 //-------------------------------------------------------------------------------------------------
 //001386DE //^_^
-void CUITile::TileDrawTex(TImage *pImage1, float f2, float f3, uint u4) {
-  LOGI("CUITile::TileDrawTex 001386DE entry");
-}
+
 //-------------------------------------------------------------------------------------------------
 //001386F6 //^_^
 void CUITile::TileDrawTex(CFTTTexture *pTexture1, float f2, float f3, uint u4) {
@@ -190,8 +201,9 @@ void CUITile::TileDrawTex(CFTTTexture *pTexture1, float f2, float f3, float f4,
 }
 //-------------------------------------------------------------------------------------------------
 //001387A8 //^_^
-void CUITile::TileDrawTexCrop(TImage *pImage1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9, uint u10) {
-  LOGI("CUITile::TileDrawTexCrop 001387A8 entry");
+void CUITile::TileDrawTex(TImage *pImage1, float f2, float f3, float f4, float f5, uint u6) {
+  LOGI("CUITile::TileDrawTex 00137EC2 entry");
+  LOGE("%x%x%x%x%x%x%x",this,pImage1,f2,f3,f4,f5,u6);
 }
 //-------------------------------------------------------------------------------------------------
 //0013885C //^_^
@@ -238,8 +250,7 @@ void CUITile::TileDrawRect(float f1, float f2, float f3, float f4, uint u5) {
 }
 //-------------------------------------------------------------------------------------------------
 //00138BDE //^_^
-void CUITile::TileDrawTex(char const *pBuf1, float f2, float f3, float f4, float f5, uint u6) {
-}
+
 //-------------------------------------------------------------------------------------------------
 //00138C24 //^_^
 void CUITile::TileDrawLineV(float f1, float f2, float f3, uint u4, bool b5) {
@@ -337,7 +348,9 @@ void CUITile::TileDrawTexCropRot(TImage *pImage1, float f2, float f3, float f4,
 //-------------------------------------------------------------------------------------------------
 //001392BA //^_^
 void CUITile::TileDrawBoxRounded(float f1, float f2, float f3, float f4, int d5, int d6) {
-  LOGI("CUITile::TileDrawBoxRounded 001392BA entry");
+  srand(time(NULL));
+  int ret = rand();
+  printf("%d%x%x%x%x%x%x", ret, f1, f2,f3,f4,d5,d6);
 }
 //-------------------------------------------------------------------------------------------------
 //00139328

+ 0 - 1
jni/CUITileNationality.h

@@ -23,7 +23,6 @@ public:
   virtual void RenderPost();        // 0013E264
   virtual EUITileAction Process();  // 0013E266
 
-  ushort field_1AA;
   int i_1AC;
   uchar uc_1B0;
 };

+ 49 - 15
jni/CrowdTextureCreationData.h

@@ -6,7 +6,9 @@
 #include "FTTAtlasGenerator.h"
 #include "CFTTModel.h"
 #include "TCrowdMember.h"
+#include "MyFTTUPtr.h"
 class TCrowdMember;
+
 /*
 001A4C50 CrowdTextureCreationData::~CrowdTextureCreationData()
 */
@@ -22,24 +24,44 @@ struct CrowdTextureCreationData_10C
   uchar b_1;
   ushort us_2;
   
-}
+};
+
+struct CrowdTextureCreationData_68
+{
+  uchar b_0;
+  uchar b_1;
+  uchar b_2;
+  uchar b_3;
+  uchar b_4;
+};
+
+struct CrowdTextureCreationData_94C
+{
+  uchar b_0;
+  uchar b_1;
+  ushort us_0;
+  ushort us_2;
+};
+
 class CrowdTextureCreationData {
 public:
   ~CrowdTextureCreationData();  // 001A4C50
 
   int miCFTTMaterialIndex_0;
-  int field_4;
-  int field_8;
-  int field_C;
-  int field_10;
+  int texture_4;
+  int texture_8;
+  int texture_C;
+  int texture_10;
   char buff_14[0x18];
   CFTTModel* model_2C;
   CFTTModel* model_30; 
-  FTTUPtr<TCrowdMember> pmembers_34;
-  CFTTRenderToTexture* texture_38;
-  FTTUPtr<UnKmowClass> field_3C;
-  UnKmowClass* field_40;
-  UnKmowClass* field_44;
+  MyFTTUPtr<TCrowdMember,0x20> pmembers_34;
+  CFTTRenderToTexture* pprenderToTexture_38[2];
+  //CFTTRenderToTexture* prenderToTexture_3C;
+
+  //FTTUPtr<UnKmowClass> field_3C;
+  CFTTRenderToTexture* prenderToTexture_40;
+  CFTTRenderToTexture* prenderToTexture_44;
   int texture_48;
   int texture_4C;
   int texture_50;
@@ -48,13 +70,25 @@ public:
   CFTTTexture* name_texture_5C;
   CFTTTexture* name_texture_60;
   CFTTTexture* name_texture_64;
-  char buff_68[0xa4];
-  
-  CrowdTextureCreationData_10C field_10c[0x20];
-  char buff_18c[0x17c0];
+  uchar buff_68[0x20][0x5];
+  uchar byte_108[4];
+  CrowdTextureCreationData_10C field_10c[0x20][0x10];
+  struct Data_90c{
+    uchar b_0;
+    uchar b_1;
+    ushort us_2;
+  }data_90c[0x4][0x4];
 
+  struct Data_94c{
+    uchar b_0;
+    uchar b_1;
+    ushort us_2;
+  } buff_94c[0x20][0x20];
   FTTUPtr<FTTAtlasGenerator> mpFTTAtlasGenerator_194C;
-  char buf_1950[0x1420];
+  FTTAtlasGeneratorNode* buf_1950[0x20][0x20];
+  uchar uc_2950[0x20];
+  char buf_2970[0x20][0x20];
+
 };
 
 #endif  //_CROWDTEXTURECREATIONDATA_H_

+ 5 - 1
jni/FE2D.cpp

@@ -101,7 +101,11 @@ void FE2D_DrawTexCol(TImage *pImage, float f1, float f2, uint a3) {
 }
 //-------------------------------------------------------------------------------------------------
 //00148EEC
-void FE2D_DrawTexScaleCol(CFTTTexture *pTexture, float f1, float f2, float f3, float f4, uint a5) {
+void FE2D_DrawTexScaleCol(CFTTTexture *a1, float a2, float a3, float a4,
+                          float a5, uint a6) {
+  srand(time(NULL));
+  int ret = rand();
+  printf("%d%d%d%d%d%d%d", a1, ret, a2, a3, a4, a5, a6);
 }
 //-------------------------------------------------------------------------------------------------
 //00148F20

+ 18 - 14
jni/FETU.cpp

@@ -27,14 +27,12 @@ bool GetAtlasData(TAtlasData *pAtlasData, char const *pName) {
 }
 //-------------------------------------------------------------------------------------------------
 //0014E008 //^_^ 单元测试通过
-void FETU_GetImage(TImage *pImage,
-                   char const *pName,
-                   bool a3,
-                   EFTTTexFormat eFormat,
-                   bool a5,
-                   bool a6,
-                   bool a7) {
-  LOGI("FETU_GetImage Entry %s", pName);
+void FETU_GetImage(TImage*a1, char const*a2, bool a3, EFTTTexFormat a4, bool a5, bool a6, bool a7)
+{
+srand(time(NULL));
+  int ret = rand();
+  printf("%x%x%s%x%x%x%x%x", ret, a1, a2, a3, a4, a5, a6, a7);
+  return;
 }
 //-------------------------------------------------------------------------------------------------
 //0014E0C6
@@ -180,15 +178,21 @@ void FETU_DrawBoxGreen(float f0, float f1, float f2, float f3, int d4, float f5,
 }
 //-------------------------------------------------------------------------------------------------
 //0014F368 //^_-  经过单元测试,功能正常
-void FETU_DrawBoxRounded(float f0, float f1, float f2, float f3, int a4, float f5, float f6, float f7, int a8) {
-  LOGI("FETU_DrawBoxRounded 0014F368 %.2f %.2f %.2f %.2f", f0, f1, f2, f3);
+void FETU_DrawBoxRounded(float a1, float a2, float a3, float a4, int a5, float a6, float a7, float a8, int a9)
+{
+srand(time(NULL));
+  int ret = rand();
+  printf("%x%x%x%x%x%x%x%x%x%x", ret, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+  return;
 }
 //-------------------------------------------------------------------------------------------------
 //001500D8 //^_- 经过单元测试,功能正常
-void FETU_DrawBoxRoundedOutline(float f0, float f1, float f2, float f3, int a4, float f5, float f6, float f7, int a8) {
-  LOGI("FETU_DrawBoxRoundedOutline 001500D8 %.2f %.2f %.2f %.2f", f0, f1, f2, f3);
-
-  LOGI("FETU_DrawBoxRoundedOutline 001500D8 end");
+void FETU_DrawBoxRoundedOutline(float a1, float a2, float a3, float a4, int a5,
+                                float a6, float a7, float a8, int a9) {
+  srand(time(NULL));
+  int ret = rand();
+  printf("%x%x%x%x%x%x%x%x%x%x", ret, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+  return;
 }
 //-------------------------------------------------------------------------------------------------
 //001504F0

+ 6 - 3
jni/FTT2D.cpp

@@ -73,6 +73,7 @@ void FTT2D_SetMaterial(int a1) {
 //-------------------------------------------------------------------------------------------------
 //0020CA4C //^_^
 void FTT2D_SetDefaultMatBlend(EFTT2D_Blend eBland) {
+  LOGE("%x",eBland);
 }
 //-------------------------------------------------------------------------------------------------
 //0020CA68 //^_^ 经过单元测试,功能正常
@@ -100,7 +101,7 @@ int FTT2D_GetMaterial() {
 //-------------------------------------------------------------------------------------------------
 //0020CAE0 //^_^ 经过单元测试,功能正常
 void FTT2D_SetTexture(CFTTTexture *pTexture, ushort a2) {
-  LOGI("FTT2D_SetTexture 0020CAE0 Entry %p", pTexture);
+  LOGI("FTT2D_SetTexture 0020CAE0 Entry %p%x", pTexture,a2);
 
   LOGI("FTT2D_SetTexture End");
 }
@@ -108,7 +109,8 @@ void FTT2D_SetTexture(CFTTTexture *pTexture, ushort a2) {
 //0020CB58 -_- 经过单元测试,功能正常
 void FTT2D_SetTextureUV(CFTT2D_TextureUV *pTextureUV, ushort a2) {
   LOGI("FTT2D_SetTextureUV entry");
-
+LOGE("%x",pTextureUV);
+LOGE("%x",a2);
   LOGI("FTT2D_SetTextureUV end");
 }
 //-------------------------------------------------------------------------------------------------
@@ -276,6 +278,7 @@ T *FTT2D_PrepareDrawFilledRect() {
 void FTT2D_DrawRect4(float f1, float f2, float f3, float f4,
                      uint argb5, uint argb6, uint argb7, uint argb8,
                      float f9, float f10, float f11) {
+LOGE("%x%x%x%x%x%x%x%x%x%x%x",f1,f2,f3,f4,argb5,argb6,argb7,argb8,f9,f10,f11);
 }
 //-------------------------------------------------------------------------------------------------
 //0020DF68 -_- 经过单元测试,功能正常
@@ -283,7 +286,7 @@ void FTT2D_DrawTexturedRect(float f1, float f2, float f3, float f4,
                             uint argb5,
                             float f6, float f7, float f8) {
   LOGI("FTT2D_DrawTexturedRect: Entry %.2f, %.2f, %.2f, %.2f", f1, f2, f3, f4);
-
+  LOGE("%x%x%x%x%x%x%x%x",f1,f2,f3,f4,argb5,f6,f7,f8);
   LOGI("FTT2D_DrawTexturedRect: End");
 }
 //-------------------------------------------------------------------------------------------------

+ 6 - 1
jni/FTTALG.h

@@ -86,8 +86,13 @@ FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount> >::Ite
 
 namespace FTTALG {
   template <typename T>
-  void  Shuffle(T*,T*){
+  void  Shuffle(T*a1,T*a2){
+    LOGE("Shuffle=%x%x",a1,a2);
+  }
 
+  template <typename T,typename TVecIterator>
+  void  Quicksort(TVecIterator a1,TVecIterator a2){
+    LOGE("Quicksort=%x%x",&a1,&a2);
   }
 template <typename TCompare,
           typename TKey,

+ 2 - 0
jni/FTTAtlasGenerator.cpp

@@ -21,5 +21,7 @@ FTTAtlasGeneratorNode* FTTAtlasGenerator::Insert(int, int) {
 //-------------------------------------------------------------------------------------------------
 //0019F756
 void FTTAtlasGenerator::Clear() {
+    LOGE("%x",this);
+
 }
 //-------------------------------------------------------------------------------------------------

+ 5 - 2
jni/FTTColour.cpp

@@ -6,8 +6,11 @@ void FTTColour_ApplyAlpha(uint, int) {
 }
 //-------------------------------------------------------------------------------------------------
 //00262D1C
-uint FTTColour_AddPercentileAlpha(uint, float) {
-  return 0;
+uint FTTColour_AddPercentileAlpha(unsigned int a1, float a2){
+srand((unsigned)time(NULL));
+	int ret = rand();
+    printf("%x%x%x",ret,a1,a2);
+	return ret;
 }
 //-------------------------------------------------------------------------------------------------
 //00262D68

+ 16 - 11
jni/FTTFont.cpp

@@ -85,12 +85,20 @@ int FTTFont_GetFont() {
 //-------------------------------------------------------------------------------------------------
 //001FC9C4 //^_- 经过单元测试,功能正常
 //001FC9D2 我的代码少UXTH R2, R0
-void FTTFont_SetAlign(EFontAlign efontalign_r0) {
+void FTTFont_SetAlign(EFontAlign a1){
+ srand(time(NULL));
+    int ret=rand();
+    printf("%d%x",ret,a1);
+    return ;
 }
 //-------------------------------------------------------------------------------------------------
 //001FC9E4
 //^_^
-void FTTFont_SetColour(uint ud_r0, uint ud_r1) {
+void FTTFont_SetColour(unsigned int a1, unsigned int a2)
+{
+    srand((unsigned)time(NULL));
+	int ret = rand();
+    printf("%x%x%x",ret,a1,a2);
 }
 //-------------------------------------------------------------------------------------------------
 //001FC9FC
@@ -211,15 +219,12 @@ void FTTFont_PrintWrapfUnicode(float f_r0, float f_r1, EFontWrapType efontwrapty
 //-------------------------------------------------------------------------------------------------
 //001FCFD8
 //^_^
-void FTTFont_PrintWrapRotUnicode(float f_r0,
-                                 float f_r1,
-                                 EFontWrapType efontwraptype_r2,
-                                 float f_r3,
-                                 float f_arg_0,
-                                 float f_arg_4,
-                                 float f_arg_8,
-                                 float f_arg_c,
-                                 wchar_t const *p_wc_arg_10) {
+void FTTFont_PrintWrapRotUnicode(float a1, float a2, EFontWrapType a3, float a4, float a5, float a6, float a7, float a8, wchar_t const* a9)
+{
+   srand(time(NULL));
+  int ret = rand();
+  printf("%x%x%x%x%x%x%x%x%x%x", ret, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+  return;
 }
 //-------------------------------------------------------------------------------------------------
 //001FD020 //^_-

+ 21 - 7
jni/FTTUPtr.h

@@ -32,16 +32,19 @@ FTTUPtr_CFTTTexture
 
 template <typename T>
 class FTTUPtr {
-public:
-  FTTUPtr(T* p) {
-    pType_0 = p;
-  };
+ public:
+  FTTUPtr(T* p) { pType_0 = p; };
 
   FTTUPtr(){};
+  // FTTUPtr(T[] * p) {
+  //   if (pType_0 != nullptr) {
+  //     delete[] pType_0;
+  //   }
 
-  ~FTTUPtr() {
-    delete pType_0;
-  };
+  //   pType_0 = p;
+  // };
+
+  ~FTTUPtr() { delete pType_0; };
 
   FTTUPtr<T>* operator=(T* other) {
     if (pType_0 != nullptr) {
@@ -52,6 +55,15 @@ public:
     return this;
   }
 
+  // FTTUPtr<T>* operator=(T** other) {
+  //   if (pType_0 != nullptr) {
+  //     delete[] pType_0;
+  //   }
+
+  //   pType_0 = *other;
+  //   return this;
+  // }
+
   void Delete() {
     if (pType_0 != nullptr) {
       delete pType_0;
@@ -63,4 +75,6 @@ public:
   T* pType_0;
 };
 
+
+
 #endif  //_FTTUPTR_H_

+ 1 - 1
jni/GFXSCENE.cpp

@@ -21,7 +21,7 @@ void GFXSCENE_Shutdown() {
 //0018BF84
 void GFXSCENE_Apply(CLightingLUTSceneSettings const* plightingLUTSceneSettings0) {
   //LOGE("GFXSCENE_Apply");
-
+  LOGE("GFXSCENE_Apply=%x",plightingLUTSceneSettings0);
   //loc_18C0F6
   return;
 }

+ 24 - 0
jni/Matrix.cpp

@@ -31,6 +31,24 @@ void MatrixMultiply_Affine(CFTTMatrix32 *dst, CFTTMatrix32 const *matrix1, CFTTM
 //计算用到的指令如VMUL、VMLA、VSTR1的种类完全相同,只是因为编译器优化导致其个数与原始的有一点点差别,
 //接上,计算索引的指令个数上也有区别,但是计算结果完全相同
 void MatrixMultiply(CFTTMatrix32 *dst, CFTTMatrix32 const *matrix1, CFTTMatrix32 const *matrix2) {
+  
+dst->d[0][0] =matrix1->d[0][0]  +matrix2->d[0][0]    ;
+dst->d[0][1] =matrix1->d[0][1]  +matrix2->d[0][1]    ;
+dst->d[0][2] =matrix1->d[0][2]  +matrix2->d[0][2]    ;
+dst->d[0][3] =matrix1->d[0][3]  +matrix2->d[0][3]    ;
+dst->d[1][0] =matrix1->d[1][0]  +matrix2->d[1][0]    ;
+dst->d[1][1] =matrix1->d[1][1]  +matrix2->d[1][1]    ;
+dst->d[1][2] =matrix1->d[1][2]  +matrix2->d[1][2]    ;
+dst->d[1][3] =matrix1->d[1][3]  +matrix2->d[1][3]    ;
+dst->d[2][0] =matrix1->d[2][0]  +matrix2->d[2][0]    ;
+dst->d[2][1] =matrix1->d[2][1]  +matrix2->d[2][1]    ;
+dst->d[2][2] =matrix1->d[2][2]  +matrix2->d[2][2]    ;
+dst->d[2][3] =matrix1->d[2][3]  +matrix2->d[2][3]    ;
+dst->d[3][0] =matrix1->d[3][0]  +matrix2->d[3][0]    ;
+dst->d[3][1] =matrix1->d[3][1]  +matrix2->d[3][1]    ;
+dst->d[3][2] =matrix1->d[3][2]  +matrix2->d[3][2]    ;
+dst->d[3][3] =matrix1->d[3][3]  +matrix2->d[3][3]  ;
+return ;
 }
 //-------------------------------------------------------------------------------------------------
 //00265F78 //???
@@ -69,6 +87,12 @@ float SquareMagnitude(CFTTVector32 const &a1) {
 //0011E7E4 ^_^
 CFTTVector32 Normalize(CFTTVector32 const &a1) {
   CFTTVector32 ret;
+  ret.float_0=a1.float_0+rand();
+  ret.float_4=a1.float_4+rand();
+  
+  ret.float_8=a1.float_8+rand();
+  
+
   return ret;
 }
 //-------------------------------------------------------------------------------------------------

+ 79 - 0
jni/MyFTTUPtr.h

@@ -0,0 +1,79 @@
+// FTTUPtr - [2020-04-13 11:57:47]
+#ifndef _MyFTTUPTR_H_
+#define _MyFTTUPTR_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "TCrowdMember.h"
+
+/*
+00191918 FTTUPtr<CGfxAdboard>::~FTTUPtr()
+00191970 FTTUPtr<CGfxAdboard>::operator=(CGfxAdboard*)
+00196CA2 FTTUPtr<CrowdTextureCreationData>::~FTTUPtr()
+00196D0E FTTUPtr<CFTTRenderHelper>::~FTTUPtr()
+00196E7C FTTUPtr<CFTTRenderHelper>::operator=(CFTTRenderHelper*)
+
+FTTUPtr_CFTTRenderHelper
+0019BBCC FTTUPtr<CGfxCrowdFlagPhysics>::~FTTUPtr()
+0019BFE8 FTTUPtr<CGfxCrowdCardGroup>::~FTTUPtr()
+0019C2F0 FTTUPtr<CGfxCrowdFlagRender>::~FTTUPtr()
+0019EAC4 FTTUPtr<CrowdTextureCreationData>::operator=(CrowdTextureCreationData*)
+0019F674 FTTUPtr<FTTAtlasGenerator>::operator=(FTTAtlasGenerator*)
+001A329C FTTUPtr<CGfxCloth>::operator=(CGfxCloth*)
+001A4CC8 FTTUPtr<FTTAtlasGenerator>::~FTTUPtr()
+001A67B0 FTTUPtr<CGfxCloth>::~FTTUPtr()
+001AE1CC FTTUPtr<CGfxPostProcess>::~FTTUPtr()
+001B92D0 FTTUPtr<CFTTTexture>::Delete()
+001C3C68 FTTUPtr<CFTTBatchModelManager>::~FTTUPtr()
+001C40D4 FTTUPtr<CFTTBatchModelManager>::operator=(CFTTBatchModelManager*)
+FTTUPtr_CFTTTexture
+
+001A4A74 FTTUPtr<FTTAtlasGeneratorNode []>::operator=(FTTAtlasGeneratorNode*)
+*/
+
+template <typename T, int N>
+class MyFTTUPtr {
+ public:
+  MyFTTUPtr(T* p) { pType_0 = p; };
+
+  MyFTTUPtr(){};
+
+  ~MyFTTUPtr() { delete[] pType_0; };
+
+  MyFTTUPtr<T,N>* operator=(T* other) {
+    if (N > 1) {
+      if (pType_0 != nullptr) {
+        delete[] pType_0;
+      }
+    } else
+      delete pType_0;
+
+    pType_0 = other;
+    return this;
+  }
+
+  // FTTUPtr<T>* operator=(T** other) {
+  //   if (pType_0 != nullptr) {
+  //     delete[] pType_0;
+  //   }
+
+  //   pType_0 = *other;
+  //   return this;
+  // }
+
+  void Delete() {
+    if (N > 1) {
+      if (pType_0 != nullptr) {
+        delete[] pType_0;
+      }
+    } else {
+      delete pType_0;
+    }
+
+    pType_0 = nullptr;
+  }
+
+  T* pType_0;
+};
+#endif  //#define _MyFTTUPTR_H_

+ 4 - 1
jni/TAABB.cpp

@@ -31,8 +31,11 @@ void TAABB::Expand( TAABB const&a2) {
 }
 //-------------------------------------------------------------------------------------------------------
 //0019F554
-void TAABB::Inflate(CFTTVector32 &a2) {
+void TAABB::Inflate(CFTTVector32 const &a1) {
+  LOGE("%x",this);
+   LOGE("%x%x%x",a1.float_0,a1.float_4,a1.float_8);
 }
+
 //-------------------------------------------------------------------------------------------------------
 //00198E28
 void TAABB::Inflate( float const&a2) {

+ 1 - 1
jni/TAABB.h

@@ -18,7 +18,7 @@ class TAABB {
 public:
   void Expand(CFTTVector32 const &a2);  // 00198E10
   void Expand(TAABB const &a2);         // 001991E4
-  void Inflate(CFTTVector32 &a2);       // 0019F554
+  void Inflate(CFTTVector32 const &a2);       // 0019F554
   void Inflate(float const &a2);        // 00198E28
   int Overlap(TAABB *a2);               // 001A4E12
   float SurfaceArea();                  // 001A50D0

+ 17 - 11
jni/TCrowd.h

@@ -2,20 +2,26 @@
 #ifndef _TCROWD_H_
 #define _TCROWD_H_
 
+#include "CFTTVector32.h"
+
+// sizeof = 0x30
 struct TGfxCrowdSeat {
-  float f_0;   // 00199E1A 由此判断是float
-  float f_4;   // 00199E66 由此判断是float
-  float f_8;   // 00199E64 由此判断是float
-  float f_C;   // 类型尚不确定,先定义成float
-  float f_10;  // 类型尚不确定,先定义成float
-  float f_14;  // 类型尚不确定,先定义成float
+  CFTTVector32 fttVector32_0;
+  CFTTVector32 fttVector32_C;
   float f_18;  // 00199E32 由此判断是float
-};
 
-enum ECrowdMemberType {
-  ECrowdMemberType_0,
-  ECrowdMemberType_1,
-  ECrowdMemberType_2
+  uint field_1C;
+  int field_20;
+  int field_24;
+  bool field_28;
+  bool field_29;
+  uint8 field_2A;
+  uint8 field_2B;
+  ushort field_2C;
+  uchar field_2E;
+  uchar field_2F;
 };
 
+
+
 #endif  //_TCROWD_H_

+ 46 - 6
jni/TCrowdMember.cpp

@@ -31,6 +31,9 @@ void TCrowdMember::Setup(ECrowdMemberType e_r1, uchar uc_r2) {
 #if 0
 
 #endif
+LOGE("%x",this);
+LOGE("%x",e_r1);
+LOGE("%x",uc_r2);
 }
 
 //-------------------------------------------------------------------------------------------------------
@@ -40,7 +43,7 @@ void TCrowdMember::Setup(ECrowdMemberType e_r1, uchar uc_r2) {
 //单元测试结果: 正常
 //编译无栈保护选项
 TCrowdMember::TCrowdMember() {
- 
+ LOGE("TCrowdMember::TCrowdMember%x",this);
 }
 
 //-------------------------------------------------------------------------------------------------------
@@ -59,10 +62,29 @@ TCrowdMember::~TCrowdMember() {
 //单元测试内容: 启动游戏到第1关,会被多次调用
 //单元测试结果: 正常
 //编译无栈保护选项
-TAABB TCrowdMember::Animate(TSATAnim_TSX* pAnim_r2, TSATAnim_TSX* pAnim_r3, unsigned int iArg_r4) {
+CFTTMatrix32 TCrowdMember::Animate(TSATAnim_TSX* pAnim_r2, TSATAnim_TSX* pAnim_r3, unsigned int iArg_r4) {
   
-  TAABB cTAABB_sp_4;
-
+  CFTTMatrix32 cTAABB_sp_4;
+  LOGE("%x",this);
+LOGE("%x",pAnim_r2);
+LOGE("%x",pAnim_r3);
+LOGE("%x",iArg_r4);
+cTAABB_sp_4.d[0][0] =rand()    ;
+cTAABB_sp_4.d[0][1] =rand()    ;
+cTAABB_sp_4.d[0][2] =rand()    ;
+cTAABB_sp_4.d[0][3] =rand()    ;
+cTAABB_sp_4.d[1][0] =rand()    ;
+cTAABB_sp_4.d[1][1] =rand()    ;
+cTAABB_sp_4.d[1][2] =rand()    ;
+cTAABB_sp_4.d[1][3] =rand()    ;
+cTAABB_sp_4.d[2][0] =rand()    ;
+cTAABB_sp_4.d[2][1] =rand()    ;
+cTAABB_sp_4.d[2][2] =rand()    ;
+cTAABB_sp_4.d[2][3] =rand()    ;
+cTAABB_sp_4.d[3][0] =rand()    ;
+cTAABB_sp_4.d[3][1] =rand()    ;
+cTAABB_sp_4.d[3][2] =rand()    ;
+cTAABB_sp_4.d[3][3] =rand()  ;
   return cTAABB_sp_4;
 }
 //-------------------------------------------------------------------------------------------------------
@@ -81,6 +103,24 @@ void TCrowdMember::swap(TCrowdMember& cCrowdMember_r0, TCrowdMember& cCrowdMembe
 //单元测试内容: 启动游戏到第1关,会被多次调用
 //单元测试结果: 正常
 //编译无栈保护选项
-void TCrowdMember::Render(CFTTMatrix32* cFTTMatrix32_r0) {
-
+void TCrowdMember::Render(CFTTMatrix32* viewmatrix) {
+  LOGE("%x%x%x%x",  viewmatrix->d[0][0]);
+  LOGE("%x%x%x%x", viewmatrix->d[0][1]);
+  LOGE("%x%x%x%x", viewmatrix->d[0][2]);
+  LOGE("%x%x%x%x", viewmatrix->d[0][3]);
+							 
+  LOGE("%x%x%x%x", viewmatrix->d[1][0]);
+  LOGE("%x%x%x%x", viewmatrix->d[1][1]);
+  LOGE("%x%x%x%x", viewmatrix->d[1][2]);
+  LOGE("%x%x%x%x", viewmatrix->d[1][3]);
+							 
+  LOGE("%x%x%x%x", viewmatrix->d[2][0]);
+  LOGE("%x%x%x%x", viewmatrix->d[2][1]);
+  LOGE("%x%x%x%x", viewmatrix->d[2][2]);
+  LOGE("%x%x%x%x", viewmatrix->d[2][3]);
+							 
+  LOGE("%x%x%x%x", viewmatrix->d[3][0]);
+  LOGE("%x%x%x%x", viewmatrix->d[3][1]);
+  LOGE("%x%x%x%x", viewmatrix->d[3][2]);
+  LOGE("%x%x%x%x", viewmatrix->d[3][3]);
 }

+ 7 - 4
jni/TCrowdMember.h

@@ -3,12 +3,15 @@
 
 #include "common.h"
 #include "TUV.h"
-#include "CGfxCrowd.h"
+//#include "CGfxCrowd.h"
 #include "SAT.h"
-#include "TCrowd.h"
 class CFTTModel;
 class TAABB;
-
+enum ECrowdMemberType {
+  ECrowdMemberType_0,
+  ECrowdMemberType_1,
+  ECrowdMemberType_2
+};
 class TCrowdMember {
 public:
   TCrowdMember();                                             // 001A40C8
@@ -16,7 +19,7 @@ public:
   static void swap(TCrowdMember&, TCrowdMember&);             // 001A4704
   void Setup(ECrowdMemberType, uchar);                        // 0019EB18
   void Render(CFTTMatrix32*);                                 // 0019F240
-  TAABB Animate(TSATAnim_TSX*, TSATAnim_TSX*, unsigned int);  // 0019EE90
+  CFTTMatrix32 Animate(TSATAnim_TSX*, TSATAnim_TSX*, unsigned int);  // 0019EE90
 public:
   ECrowdMemberType m_eCrowdMemberType_0;
   uchar m_uc_4;

+ 2 - 0
jni/TGfxCrowdState.cpp

@@ -0,0 +1,2 @@
+#include "TGfxCrowdState.h"
+byte2 TGfxCrowdState::uSpan[0x20][0x5];

+ 11 - 2
jni/TGfxCrowdState.h

@@ -2,8 +2,13 @@
 #ifndef _TGFXCROWDSTATE_H_
 #define _TGFXCROWDSTATE_H_
 #include "common.h"
-#include "CGfxCrowd.h"
 #include "TCrowd.h"
+#include "TCrowdMember.h"
+struct byte2
+{
+  uchar b_0;
+  uchar b_1;
+};
 class TGfxCrowdState {
 public:
     TGfxCrowdState(){} // 自定义构造函数
@@ -21,7 +26,11 @@ public:
   uchar m_field_11;
   // uint16  m_field_12;
   int16 m_field_12;
-  static uchar uSpan[0x140];
+  //static uchar uSpan[0x140];
+
+ static byte2 uSpan[0x20][0x5];
 };
 
+
+
 #endif  // _TGFXCROWDSTATE_H_

+ 6 - 6
jni/XSYS.cpp

@@ -35,7 +35,7 @@ int randGetRangeSeed(int a1, uint32_t a2) {
 //-------------------------------------------------------------------------------------------------
 //001F4ED0 //^_^
 int randGetRangeNoSync(uint a1) {
-  return 0;
+  
   if (!a1)
     return 0;
 
@@ -78,7 +78,7 @@ float XSYS_GetSunSetRiseTime(bool, int, int, int, float, float, int, int &, int
 //-------------------------------------------------------------------------------------------------
 //001F4F28 //^_^
 int XSYS_RandomFromSeed(int a1, int a2) {
-  return 0;
+  
   if (!a2)
     return 0;
   if (a2 <= -1)
@@ -88,7 +88,7 @@ int XSYS_RandomFromSeed(int a1, int a2) {
 //-------------------------------------------------------------------------------------------------
 //001F4F44 //^_^
 int XSYS_Random(int a1) {
-  return 0;
+  
   int rand =0;
   if (a1) {
     if (a1 <= -1) {
@@ -104,7 +104,7 @@ int XSYS_Random(int a1) {
 //-------------------------------------------------------------------------------------------------
 //001F4F60 //^_^
 int XSYS_RandomNoSync(int a1) {
-   return 0;
+   
   int result;
   if (a1)
     result = randGetRangeNoSync(a1);
@@ -154,13 +154,13 @@ int XSYS_RandomGetSeedNoSync() {
 //-------------------------------------------------------------------------------------------------
 //001F5020 //^_^
 float XSYS_RandomF(float a1) {
-  return 0.0;
+ 
   return (float)((float)randGetRange(10240) / 10240.0) * a1;
 }
 //-------------------------------------------------------------------------------------------------
 //001F5050 //^_^
 float XSYS_RandomNoSyncF(float a1) {
-  return 0.0;
+  
   return (float)((float)randGetRangeNoSync(0x2800) / 10240.0) * a1;
 }
 //-------------------------------------------------------------------------------------------------

+ 2 - 0
jni/common_type.h

@@ -29,8 +29,10 @@ typedef unsigned long ulong;    //ul
 
 #ifdef _TESTMOD_
 #define MYSTATIC
+#define MYCONST
 #else
 #define MYSTATIC static
+#define MYCONST  const
 #endif
 
 #endif  //_COMMON_TYPE_H_

File diff suppressed because it is too large
+ 0 - 0
obj/local/armeabi-v7a/objs/Hero/linker.list


+ 1 - 0
obj/local/armeabi-v7a/objs/cpufeatures/archiver.list.tmp

@@ -0,0 +1 @@
+./obj/local/armeabi-v7a/objs/cpufeatures/cpu-features.o 

Some files were not shown because too many files changed in this diff