BasaltMeter/BasaltPresenter/Presenter/main.cpp

#include "dll_loader.hpp"
#include "cmd_client.hpp"
#include "stopwatch.hpp"
#include <basalt/char_types.hpp>
#include <basalt/engine.hpp>
#include <basalt/deliver.hpp>
#include <spdlog/spdlog.h>

namespace engine = ::basalt::shared::engine;
using engine::EngineConfig;
using engine::IEngine;
namespace deliver = ::basalt::shared::deliver;
using deliver::DeliverConfig;
using deliver::IDeliver;
namespace object_loader = ::basalt::shared::object_loader;
using object_loader::IObjectLoader;
using object_loader::ObjectLoaderConfig;
namespace anime_loader = ::basalt::shared::anime_loader;
using anime_loader::AnimeLoaderConfig;
using anime_loader::IAnimeLoader;

namespace dll_loader = ::basalt::presenter::dll_loader;
using dll_loader::DllKind;
using dll_loader::DllLoader;

using ::basalt::presenter::cmd_client::CmdClient;
using ::basalt::presenter::stopwatch::Stopwatch;

int main(int argc, char* argv[]) {
    auto client = CmdClient();
    spdlog::info("Waiting BasaltTrainer...");
    auto payload = client.wait_handshake();
    spdlog::info("BasaltTrainer Requirements:");
    spdlog::info(BSTEXT("\tHeadless Mode: {}"), payload.headless ? BSTEXT("Yes") : BSTEXT("No"));
    spdlog::info(BSTEXT("\tResolution: {} x {}"), payload.width, payload.height);
    spdlog::info(BSTEXT("\tEngine: {}"), payload.engine_name);
    spdlog::info(BSTEXT("\tEngine Device: {}"), payload.engine_device);
    spdlog::info(BSTEXT("\tDeliver: {}"), payload.deliver_name);
    spdlog::info(BSTEXT("\tDeliver Device: {}"), payload.deliver_device);
    spdlog::info(BSTEXT("\tObject Loader: {}"), payload.object_loader_name);
    spdlog::info(BSTEXT("\tObject Loader File: {}"), payload.object_loader_file);
    spdlog::info(BSTEXT("\tAnime Loader: {}"), payload.anime_loader_name);
    spdlog::info(BSTEXT("\tAnime Loader File: {}"), payload.anime_loader_file);

    spdlog::info("Finding plugins...");
    auto engine_dll = DllLoader(DllKind::Engine, payload.engine_name);
    auto deliver_dll = DllLoader(DllKind::Deliver, payload.deliver_name);
    auto object_loader_dll = DllLoader(DllKind::ObjectLoader, payload.object_loader_name);
    auto anime_loader_dll = DllLoader(DllKind::AnimeLoader, payload.anime_loader_name);

    spdlog::info("Allocating instances...");
    auto* anime_loader_inst = anime_loader_dll.create_instance<IAnimeLoader>();
    auto* object_loader_inst = object_loader_dll.create_instance<IObjectLoader>();
    auto* deliver_inst = deliver_dll.create_instance<IDeliver>();
    auto* engine_inst = engine_dll.create_instance<IEngine>();

    spdlog::info("Starting up...");
    AnimeLoaderConfig anime_loader_config{.filename = payload.anime_loader_file};
    anime_loader_inst->load(std::move(anime_loader_config));
    ObjectLoaderConfig object_loader_config{.filename = payload.object_loader_file};
    object_loader_inst->load(std::move(object_loader_config));
    //DeliverConfig deliver_config{.device = payload.deliver_device};
    //deliver_inst->startup(std::move(deliver_config));
    EngineConfig engine_config{.headless = payload.headless,
                               .width = payload.width,
                               .height = payload.height,
                               //.deliver = deliver_inst->get_guid(),
                               .object_loader = object_loader_inst,
                               .anime_loader = anime_loader_inst};
    engine_inst->startup(std::move(engine_config));

    spdlog::info("Start to running.");
    Stopwatch stopwatch(120);
    while (true) {
        auto req_stop = engine_inst->tick();
        stopwatch.tick();
        auto can_stop = client.tick(req_stop);
        if (can_stop) break;
    }

    spdlog::info("Shutting down...");
    engine_inst->shutdown();

    spdlog::info("Destroying instances...");
    engine_dll.destroy_instance(engine_inst);
    deliver_dll.destroy_instance(deliver_inst);
    object_loader_dll.destroy_instance(object_loader_inst);
    anime_loader_dll.destroy_instance(anime_loader_inst);

    spdlog::info("Program stop.");
}