BattleDataInstaller.h

Go to the documentation of this file.

/*
 * V-Gears
 * Copyright (C) 2022 V-Gears Team
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "common/BinGZipFile.h"
#include "common/TypeDefine.h"
#include "data/BattleSceneFile.h"
#include "data/VGearsLGPArchive.h"
 
class BattleDataInstaller{
 
 
    public:
 
        BattleDataInstaller(
          const std::string input_dir, const std::string output_dir,
          Ogre::ResourceGroupManager* res_mgr
        );
 
        ~BattleDataInstaller();
 
        unsigned int InitializeScenes();
 
        unsigned int InitializeModels();
 
        unsigned int ProcessScene();
 
        unsigned int ProcessModel();
 
        unsigned int ConvertModelsInit();
 
        unsigned int ConvertModel();
 
        void WriteEnemies();
 
        void WriteAttacks();
 
        void WriteFormations();
 
        void WriteCharacterData();
 
        void WriteSceneData();
 
    private:
 
        struct Model{
 
            std::string id;
 
            std::string hrc;
 
            std::string anim;
 
            std::vector<std::string> p;
 
            std::vector<std::string> tex;
 
            std::vector<std::string> a;
 
            Model(): id(""), hrc(""), anim(""){
                p.clear();
                tex.clear();
                a.clear();
            }
 
        };
 
        struct CharacterModel{
 
            std::string name;
 
            std::string model;
        };
 
        struct SceneModel{
 
            int id;
 
            std::string model;
 
            std::string description;
        };
 
        struct CharacterData{
 
            unsigned int id;
 
            std::vector<CharacterModel> models;
        };
 
        File* ExtractGZipScene(File file);
 
        std::string BuildEnemyFileName(Enemy enemy);
 
        std::string BuildAttackFileName(Attack attack);
 
        void ExportMesh(const std::string outdir, const Ogre::MeshPtr &mesh);
 
        void GenerateRsdFiles(Model model, std::string path);
 
        void DecompileHrc(File compiled, Model model, std::string path, std::string skeleton_name);
 
        void DecompileSceneHrc(
          File compiled, Model model, std::string path, std::string skeleton_name
        );
 
        std::string input_dir_;
 
        std::string output_dir_;
 
        Ogre::ResourceGroupManager* res_mgr_;
 
        std::function<void(std::string)> write_output_line_;
 
        unsigned int next_scene_;
 
        unsigned int total_scenes_;
 
        File scene_bin_;
 
        std::vector<File*> scenes_uncompressed_;
 
        std::vector<BattleSceneFile> scenes_;
 
        std::vector<Enemy> enemies_;
 
        std::vector<CharacterData> character_data_;
 
        std::vector<SceneModel> scene_data_;
 
        std::map<int, std::string> enemy_map_;
 
        std::vector<Attack> attacks_;
 
        std::map<int, std::string> attack_map_;
 
        std::vector<Formation> formations_;
 
        std::map<int, std::string> formation_map_;
 
        std::vector<File> battle_lgp_files_;
 
        std::vector<std::string> battle_lgp_file_names_;
 
        unsigned int next_model_to_process_;
 
        unsigned int next_model_to_convert_;
 
        std::vector<Model> models_;
 
        std::vector<std::string> materials_;
 
 
};