hero_head_5_7/jni/CGfxEnv.cpp

#include "CGfxEnv.h"
#include "CFTTFileIterator.h"
#include "CFTTFileSystem.h"
CFTTMatrix32 CGfxEnv::ms_mMatrix;
TAvailableModel CGfxEnv::ms_tAvailableModels[6];
bool CGfxEnv::ms_bDirectoriesScanned;
 TModelInfoDescription *CGfxEnv::ms_pConstructionModels[6];
//-------------------------------------------------------------------------------------------------
// 001A9034
CGfxEnv::CGfxEnv() {}
//-------------------------------------------------------------------------------------------------
// 001A9036
CGfxEnv::~CGfxEnv() {}
//-------------------------------------------------------------------------------------------------
// 001A9038
void CGfxEnv::Init(TEnvConfig const &, int, bool) {}
//-------------------------------------------------------------------------------------------------
// 001A90D4
void CGfxEnv::ProcessSlicedLoad(int) {}
//-------------------------------------------------------------------------------------------------
// 001A9264
void CGfxEnv::EnableSlicedLoad() {}
//-------------------------------------------------------------------------------------------------
// 001A9274 //^_-
void CGfxEnv::ScanStadiumModelsDirectory() {
  // 1a928a
  if (CGfxEnv::ms_bDirectoriesScanned)
    return;

  CFTTFileIterator* fileiter_34 = NULL;
  memset(CGfxEnv::ms_pConstructionModels, 0, sizeof(CGfxEnv::ms_pConstructionModels));

  // 1a92b8
  CFTTFileSystem* filesystem = CFTTFileSystem::FindFileSystem("PKG");

  // 1a92c6
  filesystem->OpenDir("PKG:/Data/env/stadium/", &fileiter_34);

  do {  // 1a92f0

    // 1a92f6
    if (!fileiter_34->IsValid())
      break;

    // 1a9302
    if (fileiter_34->IsDirectory())
      continue;

    // 1a930c
    char* name_r6 = fileiter_34->GetName();
    // 1a9312
    strlwr(name_r6);
    // 1a931a
    if (!strstr(name_r6, ".ftm"))
      continue;

    // 1a9324
    int secttype_r7 = CGfxEnv::GetSectionTypeFromFileName(name_r6);

    // 1a932e
    if (strstr(name_r6, "corner")) {
      // 1a9334
      secttype_r7 = 0;
    }
    // 1a933c
    else if (strstr(name_r6, "end")) {
      // 1a9342
      secttype_r7 = 1;
    }
    // 1a934a
    else if (strstr(name_r6, "side")) {
      // 1a9350
      secttype_r7 = 2;
    }
    // 1a9358
    else if (strstr(name_r6, "exterior")) {
      // 1a935e
      secttype_r7 = 3;
    } else if (strstr(name_r6, "surround")) {  // 1a9366
      // 1a936c
      secttype_r7 = 4;
    } else if (secttype_r7 == -1) {  // 1a9370
      continue;
    }

    TAvailableModel* model = &CGfxEnv::ms_tAvailableModels[secttype_r7];
    // 1a9382
    if (model->InfoCount_1400 > 127)
      continue;

    TEnvStadiumModelInfo* modelinfo = &model->ModelInfo_0[model->InfoCount_1400];

    // 1a93a2
    strlcpy(modelinfo->text_0, strlwr(name_r6), sizeof(modelinfo->text_0));

    // 1a93a8
    TModelInfoDescription* desc = CGfxEnv::FindModelInfoDescription(modelinfo->text_0);
    modelinfo->desc_24 = desc;

    // 1a93ac
    if (desc != nullptr) {
      // 1a93b2
      modelinfo->height_20 = desc->height_48;
      // 1a93b6 1a93c0 1a93c8 1a93cc
      if (desc && !CGfxEnv::ms_pConstructionModels[secttype_r7] && strstr(desc->text_4, "construction"))
        CGfxEnv::ms_pConstructionModels[secttype_r7] = desc;
    } else {
      // 1a93d4
      modelinfo->height_20 = -1;
    }

    CGfxEnv::ms_tAvailableModels[secttype_r7].InfoCount_1400++;

    // 1a93ee 1a93f0
  } while (!fileiter_34->Next());

  // 1a93f8
  if (fileiter_34)
    delete fileiter_34;
  // 1a9404
  filesystem = CFTTFileSystem::FindFileSystem("PKG");

  // 1a9412
  filesystem->OpenDir("PKG:/Data/env/dressing/", &fileiter_34);
  do {  // 1a942e
    // 1a9434
    if (!fileiter_34->IsValid())
      break;
    // 1a943e
    if (fileiter_34->IsDirectory())
      continue;

    // 1a9448
    char* name_r6 = fileiter_34->GetName();
    // 1a944e 1a9452 1a9458
    if (!strstr(name_r6, ".ftm") && !strstr(name_r6, ".FTM"))
      continue;
    TAvailableModel& model = CGfxEnv::ms_tAvailableModels[5];
    // 1a9464
    if (model.InfoCount_1400 > 127)
      continue;

    TEnvStadiumModelInfo& modelinfo = model.ModelInfo_0[model.InfoCount_1400];
    // 1a947a 1a9484
    strlcpy(modelinfo.text_0, strlwr(name_r6), 32);

    model.InfoCount_1400++;

    // 1a9498 1a949a
  } while (!fileiter_34->Next());

  if (fileiter_34)
    delete fileiter_34;

  char text_78[64];
  // 1a961e
  for (uint i_r0 = 0; i_r0 != 6; ++i_r0) {
    // 1a94c2
    TAvailableModel& model = CGfxEnv::ms_tAvailableModels[i_r0];
    // 1a94c6
    if (uint(i_r0 - 3) >= 3) {  // 1a94cc
      // 1a94e2
      memset(&model.EntryCount_1404, 0, 0x1884);

      // 1a9600
      for (int j_fp = 0; j_fp < model.InfoCount_1400; j_fp++) {
        // 1a94f6
        TEnvStadiumModelInfo& modelinfo = model.ModelInfo_0[j_fp];
        // 1a94fe
        int len_r0 = strlen(modelinfo.text_0);
        int len_r1 = len_r0;
        // 1a951a
        while (len_r1 != 0) {
          // 1a950e
          if (modelinfo.text_0[len_r1 - 1] == '_')
            text_78[len_r1 - 1] = ' ';
          else
            text_78[len_r1 - 1] = modelinfo.text_0[len_r1 - 1];
          len_r1--;
          // 1a9518
        }
        text_78[len_r0] = '\0';

        char text_38[64];
        char char_33;  // TAvailableModelEntry的特征
        int tmp_2c;    // TModelItem 的特征
        char char_2b;
        // 1a9538
        sscanf((const char*)text_78, "%s %c %i %c.ftm", text_38, &char_33, &tmp_2c, &char_2b);

        int EntryIndex_r2 = -1;
        // 1a9556
        while ((++EntryIndex_r2) < model.EntryCount_1404) {
          // 1a9562
          if (char_33 == model.Entry_1408[EntryIndex_r2].field_0)
            break;
        }

        // 1a9556
        if (EntryIndex_r2 >= model.EntryCount_1404) {
          // 1a956a
          EntryIndex_r2 = model.EntryCount_1404;
          model.EntryCount_1404++;
        }

        TAvailableModelEntry& Entry_r6 = model.Entry_1408[EntryIndex_r2];
        // 1a9574
        Entry_r6.field_0 = char_33;

        int ItemIndex_r3 = -1;
        // 1a9594
        while ((++ItemIndex_r3) < Entry_r6.ItemCount_4) {
          // 1a959c
          if (tmp_2c == Entry_r6.Item_8[ItemIndex_r3].field_0) {  // 1a95a0
            break;
          }
        }
        // 1a9594
        if (ItemIndex_r3 >= Entry_r6.ItemCount_4) {
          Entry_r6.ItemCount_4 = ItemIndex_r3 + 1;
        }

        TModelItem& Item = Entry_r6.Item_8[ItemIndex_r3];

        Item.field_0 = tmp_2c;
        Item.field_8[Item.count_4++] = char_2b;
        // 1a95fa
      }
      // 1a9602
    }
    // 1a9606

    // 1a961a
  }

  // 1a9684
  for (int i_r6 = 0; i_r6 != 5; i_r6++) {
    TAvailableModel* r4_pModel = &CGfxEnv::ms_tAvailableModels[i_r6];

    // 1a964a
    CGfxEnv::InsertionSortStadiumModelInfo(r4_pModel->ModelInfo_0,
                                           r4_pModel->InfoCount_1400);

    for (int r2_i = 0; r2_i < r4_pModel->InfoCount_1400; r2_i++) {  // 001A965E
      // 001A9662
      TEnvStadiumModelInfo* r3_pModelInfo = &r4_pModel->ModelInfo_0[r2_i];
      r4_pModel->field_2C88 = r3_pModelInfo->height_20;
      // 1a966a
      if (r3_pModelInfo->height_20 != 0)
        break;
    }

    // loc_1A9670
    r4_pModel->field_2C8C = r4_pModel->ModelInfo_0[r4_pModel->InfoCount_1400 - 1].height_20;
  }
  CGfxEnv::ms_bDirectoriesScanned = true;
}

//-------------------------------------------------------------------------------------------------
// 001A96C8
void CGfxEnv::CreateStadiumDressingTextures(int) {}
//-------------------------------------------------------------------------------------------------
// 001A9C2C
void CGfxEnv::StadiumAdd(TEnvConfigStadium const *, int) {}
//-------------------------------------------------------------------------------------------------
// 001A9D94
void CGfxEnv::EditSeatsTexture(uint) {}
//-------------------------------------------------------------------------------------------------
// 001A9ED8
void CGfxEnv::ObjectsAdd(TEnvConfig const *, int) {}
//-------------------------------------------------------------------------------------------------
// 001A9FA4
void CGfxEnv::SetupCrowd(EStadiumSection, int) {}
//-------------------------------------------------------------------------------------------------
// 001AA084
void CGfxEnv::GetStadiumCapacity(TEnvConfig *) {}
//-------------------------------------------------------------------------------------------------
// 001AA0C0
TModelInfoDescription *CGfxEnv::FindModelInfoDescription(char *a1) {
  LOGE("FindModelInfoDescription%s",a1);
  return (TModelInfoDescription*)rand();
}
//-------------------------------------------------------------------------------------------------
// 001AA0F4
void CGfxEnv::GetSectionCapacity(EStadiumSection) {}
//-------------------------------------------------------------------------------------------------
// 001AA100
CFTTMatrix32 CGfxEnv::GetSectionMatrix(EStadiumSection e, bool b) {
  CFTTMatrix32 ret;

  return ret;
}
//-------------------------------------------------------------------------------------------------
// 001AA17C
void CGfxEnv::GetStadiumModelInfo(EStadiumSection, char const *) {}
//-------------------------------------------------------------------------------------------------
// 001AA1F0
void CGfxEnv::UpdateStadiumSection(TEnvConfig const *, EStadiumSection) {}
//-------------------------------------------------------------------------------------------------
// 001AA24C
int CGfxEnv::ModelGet(char const *, bool, int, EStadiumSection) { return 0; }
//-------------------------------------------------------------------------------------------------
// 001AA3F4
int CGfxEnv::GetAvailableIndexFromModelIndex(EStadiumSection) { return 0; }
//-------------------------------------------------------------------------------------------------
// 001AA458
void CGfxEnv::CalculateSectionCapacity(EStadiumSection) {}
//-------------------------------------------------------------------------------------------------
// 001AA45C
void CGfxEnv::LoadSectionTextures(TEnvModel *, int) {}
//-------------------------------------------------------------------------------------------------
// 001AA478
void CGfxEnv::UpdateStadiumFloodlights() {}
//-------------------------------------------------------------------------------------------------
// 001AA4CC
int CGfxEnv::GetSectionTypeFromSection(EStadiumSection) { return 0; }
//-------------------------------------------------------------------------------------------------
// 001AA4E4
void CGfxEnv::GetSectionTypeInfo(EStadiumSectionType) {}
//-------------------------------------------------------------------------------------------------
// 001AA4F8
void CGfxEnv::Init(char *, int, bool) {}
//-------------------------------------------------------------------------------------------------
// 001AA588
void CGfxEnv::EnvConfigLoad(TEnvConfig *, CFTTXmlReaderNode) {}
//-------------------------------------------------------------------------------------------------
// 001AA5B4
int CGfxEnv::GetSectionTypeFromFileName(char const *a1) {
    LOGE("GetSectionTypeFromFileName%s",a1);
   return rand(); }
//-------------------------------------------------------------------------------------------------
// 001AA624
// 001AA624 //^_-
void CGfxEnv::InsertionSortStadiumModelInfo(TEnvStadiumModelInfo *pModeInfo1,
                                            int InfoCnt2) {
  LOGI("CGfxEnv::InsertionSortStadiumModelInfo 001AA624 entry");
  char text_8[0x20];

  for (int r10_i = 1; r10_i < InfoCnt2; ++r10_i) {
       // loc_1AA6C0
     // loc_1AA648
    memcpy(&text_8, pModeInfo1[r10_i].text_0,sizeof(pModeInfo1[r10_i].text_0));

    int height_r8 = pModeInfo1[r10_i].height_20;
    TModelInfoDescription *desc_r5 = pModeInfo1[r10_i].desc_24;

    int j_r6 = r10_i;
    for (; j_r6 > 0 &&pModeInfo1[j_r6 - 1].desc_24->height_48 > desc_r5->height_48;j_r6--) {
             // 1aa680
      memcpy(pModeInfo1 + j_r6, pModeInfo1 + j_r6 - 1,sizeof(TEnvStadiumModelInfo));
    }
    // loc_1AA6A0
    memcpy(pModeInfo1[j_r6].text_0, text_8, 0x20);
    pModeInfo1[j_r6].height_20 = height_r8;
    pModeInfo1[j_r6].desc_24 = desc_r5;
         // 1aa6be
  }

  for (int i_r1 = 0, i_r2 = 0; i_r1 < InfoCnt2; i_r1++) {
         // 1aa6ce
        if (pModeInfo1[i_r1].desc_24->field_4C) pModeInfo1[i_r1]
            .desc_24->field_44 = (i_r2++);
  }

  LOGI("CGfxEnv::InsertionSortStadiumModelInfo 001AA624 end");
}
//-------------------------------------------------------------------------------------------------
// 001AA6FC
void CGfxEnv::GetSectionSubTypeInfo(EStadiumSectionType, char) {}
//-------------------------------------------------------------------------------------------------
// 001AA73C
void CGfxEnv::GetTierSubSectionInfo(EStadiumSectionType, char, int) {}
//-------------------------------------------------------------------------------------------------
// 001AA76C
void CGfxEnv::StadiumConfigLoad(TEnvConfig *, CFTTXmlReaderNode *) {}
//-------------------------------------------------------------------------------------------------
// 001AA970
void CGfxEnv::ObjectsConfigLoad(TEnvConfig *, CFTTXmlReaderNode *) {}
//-------------------------------------------------------------------------------------------------
// 001AABA8
bool CGfxEnv::ModelExists(char const *) { return 0; }
//-------------------------------------------------------------------------------------------------
// 001AABF4
void CGfxEnv::StrToPos(char const *) {}
//-------------------------------------------------------------------------------------------------
// 001AACB2
void CGfxEnv::EnvConfigSave(TEnvConfig *, CFTTXmlWriterNode) {}
//-------------------------------------------------------------------------------------------------
// 001AACCC
void CGfxEnv::StadiumConfigSave(TEnvConfig *, CFTTXmlWriterNode *) {}
//-------------------------------------------------------------------------------------------------
// 001AAE50
void CGfxEnv::ObjectsConfigSave(TEnvConfig *, CFTTXmlWriterNode *) {}
//-------------------------------------------------------------------------------------------------
// 001AAFD0
void CGfxEnv::Process(float) {}
//-------------------------------------------------------------------------------------------------
// 001AB004
void CGfxEnv::ObjectUpdate(TEnvObject *) {}
//-------------------------------------------------------------------------------------------------
// 001AB08C
void CGfxEnv::ProcessSectionUpgradeAnimation() {}
//-------------------------------------------------------------------------------------------------
// 001AB1C4
void CGfxEnv::RenderObjStaticShadows() {}
//-------------------------------------------------------------------------------------------------
// 001AB1FC
void CGfxEnv::ObjectShadowRender(TEnvObject *, bool) {}
//-------------------------------------------------------------------------------------------------
// 001AB324
void CGfxEnv::RenderObjDynamicShadows() {}
//-------------------------------------------------------------------------------------------------
// 001AB35C
bool CGfxEnv::RenderObjDynamicShadowsHQ(uint, CFTTModel *&, CFTTMatrix32 &) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
// 001AB384
void CGfxEnv::GetShadowInfo(TEnvObject *, CFTTModel *&, CFTTMatrix32 &) {}
//-------------------------------------------------------------------------------------------------
// 001AB478
void CGfxEnv::RenderOpaque() {}
//-------------------------------------------------------------------------------------------------
// 001AB4CC
void CGfxEnv::ObjectRender(TEnvObject *) {}
//-------------------------------------------------------------------------------------------------
// 001AB604
bool CGfxEnv::StadiumVisibilityCheck() { return 0; }
//-------------------------------------------------------------------------------------------------
// 001AB640
void CGfxEnv::StadiumElementRender(int) {}
//-------------------------------------------------------------------------------------------------
// 001AB884
void CGfxEnv::RenderDecal() {}
//-------------------------------------------------------------------------------------------------
// 001AB8A8
void CGfxEnv::StadiumElementRenderDecal(int) {}
//-------------------------------------------------------------------------------------------------
// 001AB97C
void CGfxEnv::RenderAlpha() {}
//-------------------------------------------------------------------------------------------------
// 001AB9A0
void CGfxEnv::StadiumElementRenderAlpha(int) {}
//-------------------------------------------------------------------------------------------------
// 001ABA08
void CGfxEnv::SetStadiumSectionCustomColour(EStadiumSection, uint) {}
//-------------------------------------------------------------------------------------------------
// 001ABA2C
void CGfxEnv::ResetSelectedStadiumElement(EStadiumSection) {}
//-------------------------------------------------------------------------------------------------
// 001ABA40
void CGfxEnv::GetAnimationInfo(EStadiumSection) {}
//-------------------------------------------------------------------------------------------------
// 001ABA54
void CGfxEnv::ResetUpgradeAnimationInfo() {}
//-------------------------------------------------------------------------------------------------
// 001ABA80
void CGfxEnv::InitialiseSectionUpgradeAnimation(EStadiumSection,
                                                ESectionUpgradeAnimType,
                                                void (*)(EStadiumSection),
                                                void (*)(EStadiumSection)) {}
//-------------------------------------------------------------------------------------------------
// 001ABAE0
void CGfxEnv::GetSectionModel(EStadiumSection) {}
//-------------------------------------------------------------------------------------------------
// 001ABB04
void CGfxEnv::GetOrientedSectionFromSection(EStadiumSection, int) {}
//-------------------------------------------------------------------------------------------------
// 001ABB3C
void CGfxEnv::Shutdown() {}
//-------------------------------------------------------------------------------------------------
// 001ABBF0
void CGfxEnv::FreeStadiumDressingTextures() {}
//-------------------------------------------------------------------------------------------------
// 001ABC1C
int CGfxEnv::GetNumObjects() { return 0; }
//-------------------------------------------------------------------------------------------------
// 001ABC2C
void CGfxEnv::ObjectsReset() {}
//-------------------------------------------------------------------------------------------------
// 001ABC3C
bool CGfxEnv::UseShadowMapOnStadium() { return 0; }
//-------------------------------------------------------------------------------------------------
// 001ABCB4
CFTTMatrix32 CGfxEnv::SetupCommon(EStadiumSection) {
  CFTTMatrix32 ret;

  return ret;
}
//-------------------------------------------------------------------------------------------------
// 001AC058
void CGfxEnv::StadiumElementShadowRender(int) {}
//-------------------------------------------------------------------------------------------------
// 001AC260
void CGfxEnv::GetObjectModel(int) {}
//-------------------------------------------------------------------------------------------------
// 001AC274
void CGfxEnv::SetSectionConstructing(TEnvConfig &, EStadiumSection) {}
//-------------------------------------------------------------------------------------------------
// 001AC2A8
void CGfxEnv::SetFrontendExterior(TEnvConfig &) {}
//-------------------------------------------------------------------------------------------------
// 001AC2BC
void CGfxEnv::ObjectAdd(char *, TPoint3D, int, int, float) {}
//-------------------------------------------------------------------------------------------------
// 001AC318
void CGfxEnv::ObjectUpdateLive(int, TEnvConfigObject *) {}
//-------------------------------------------------------------------------------------------------
// 001AC374
void CGfxEnv::InitCameraFlashes() {}
//-------------------------------------------------------------------------------------------------
// 001AC378
void CGfxEnv::SetStadiumName(wchar_t *) {}
//-------------------------------------------------------------------------------------------------
// 001AC484
void CGfxEnv::CreateStadiumDressingBackground(int, int, int, int, int, uint &,
                                              uint &, bool, CFTTTexture *) {}
//-------------------------------------------------------------------------------------------------
// 001AC6F8
void CGfxEnv::PrintStadiumDressingText(wchar_t *, int, int, uint, uint, int) {}
//-------------------------------------------------------------------------------------------------
// 001AC848
void CGfxEnv::GenerateTrainingEnvConfig(TEnvConfig &, int) {}
//-------------------------------------------------------------------------------------------------
// 001AC94C
void CGfxEnv::GenerateNewStadium(TEnvConfig &, int) {}
//-------------------------------------------------------------------------------------------------
// 001AC978 //乱写的
CFTTAABB32 CGfxEnv::GetTotalAABB() {
  CFTTAABB32 ret;
  ret.filed_0.float_0 = rand();
  ret.filed_0.float_4 = rand() / 0xf;
  ret.filed_0.float_8 = 1;
  int rt = rand();
  if (rt > 10) ret.filed_c.float_0 = 1.0;
  for (int i = 0; i < rand(); i++) {
    printf("dasdsadas");
  }
  return ret;
}
//-------------------------------------------------------------------------------------------------
// 001ACA28
void CGfxEnv::StadiumElementShadowMapRender(int, CFTTFrustum32 const &) {}
//-------------------------------------------------------------------------------------------------
// 001E6944
void CGfxEnv::SetMatrix(CFTTMatrix32) {}
//-------------------------------------------------------------------------------------------------