add more handshake output

BasaltPresenter/Plugins/ObjectLoader/ObjObjectLoader/main.cpp

@@ -3,6 +3,8 @@
 #include <tiny_obj_loader.h>
 #include <vector>
 #include <string>
+#include <filesystem>
+#include <fstream>
 
 namespace object_loader = ::basalt::shared::object_loader;
 using object_loader::IObjectLoader;
@@ -30,9 +32,15 @@ public:
         std::string err;
 
         // Load the OBJ file
-        if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &err, this->config.filename.c_str())) {
+        std::ifstream fs;
+        fs.open(std::filesystem::path(this->config.filename));
+        if (!fs.is_open()) {
+            throw std::runtime_error("fail to open obj file");
+        }
+        if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &err, &fs)) {
             throw std::runtime_error("fail to load obj file");
         }
+        fs.close();
 
         // Create one object from all shapes in the OBJ file
         std::vector<Vector3> vertices;

BasaltPresenter/Presenter/cmd_client.cpp

@@ -28,8 +28,8 @@ namespace basalt::presenter::cmd_client {
         m_PipeOperator.read_pod(handshake_payload.height);
         m_PipeOperator.read_bsstring(handshake_payload.engine_name);
         m_PipeOperator.read_pod(handshake_payload.engine_device);
-        m_PipeOperator.read_bsstring(handshake_payload.delivery_name);
+        m_PipeOperator.read_bsstring(handshake_payload.deliver_name);
-        m_PipeOperator.read_pod(handshake_payload.delivery_device);
+        m_PipeOperator.read_pod(handshake_payload.deliver_device);
         m_PipeOperator.read_bsstring(handshake_payload.object_loader_name);
         m_PipeOperator.read_bsstring(handshake_payload.object_loader_file);
         m_PipeOperator.read_bsstring(handshake_payload.anime_loader_name);

BasaltPresenter/Presenter/cmd_client.hpp

@@ -31,8 +31,8 @@ namespace basalt::presenter::cmd_client {
         std::uint32_t height;
         shared::char_types::BSString engine_name;
         std::uint32_t engine_device;
-        shared::char_types::BSString delivery_name;
+        shared::char_types::BSString deliver_name;
-        std::uint32_t delivery_device;
+        std::uint32_t deliver_device;
         shared::char_types::BSString object_loader_name;
         shared::char_types::BSString object_loader_file;
         shared::char_types::BSString anime_loader_name;

BasaltPresenter/Presenter/main.cpp

@@ -12,6 +12,12 @@ 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;
@@ -25,36 +31,61 @@ int main(int argc, char* argv[]) {
     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("\tDeliver: {}"), payload.delivery_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.delivery_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 resources...");
+    spdlog::info("Allocating instances...");
-    auto* engine = engine_dll.create_instance<IEngine>();
+    auto* anime_loader_inst = anime_loader_dll.create_instance<IAnimeLoader>();
-    //auto* deliver = deliver_dll.create_instance<IDeliver>();
+    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>();
 
-    EngineConfig engine_config{.headless = false, .width = payload.width, .height = payload.height};
+    spdlog::info("Starting up...");
-    engine->startup(std::move(engine_config));
+    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->tick();
+        auto req_stop = engine_inst->tick();
         stopwatch.tick();
         auto can_stop = client.tick(req_stop);
         if (can_stop) break;
     }
 
-    spdlog::info("Destroying resources...");
+    spdlog::info("Shutting down...");
-    engine->shutdown();
+    engine_inst->shutdown();
-    engine_dll.destroy_instance(engine);
+
+    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.");
 }

BasaltPresenter/Shared/basalt/anime_loader.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include "math.hpp"
+#include "char_types.hpp"
 #include <map>
 #include <functional>
 
@@ -29,7 +30,7 @@ namespace basalt::shared::anime_loader {
     };
 
     struct AnimeLoaderConfig {
-
+        char_types::BSString filename; ///< The file to be loaded by loader.
     };
 
     enum class AnimeLoaderStatus {

BasaltPresenter/Shared/basalt/deliver.hpp

@@ -1,10 +1,11 @@
 #pragma once
 #include "guid.hpp"
+#include <cinttypes>
 
 namespace basalt::shared::deliver {
 
     struct DeliverConfig {
-        guid::Guid engine; ///< The GUID of render engine.
+        std::uint32_t device; ///< The selected device if possible.
     };
 
     enum class DeliverStatus {

BasaltPresenter/Shared/basalt/object_loader.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include "math.hpp"
+#include "char_types.hpp"
 #include <vector>
 #include <string>
 
@@ -22,7 +23,7 @@ namespace basalt::shared::object_loader {
     };
 
     struct ObjectLoaderConfig {
-        std::string filename;
+        char_types::BSString filename;
     };
 
     enum class ObjectLoaderStatus {

BasaltTrainer/main.py

@@ -25,7 +25,7 @@ def main():
         deliver_name="BasaltPipeDeliver",
         deliver_device=0,
         object_loader_name="BasaltObjObjectLoader",
-        object_loader_file="",
+        object_loader_file="D:\\Repo\\BasaltMeter\\BasaltPresenter\\out\\scene.obj",
         anime_loader_name="BasaltChickenNuggetAnimeLoader",
         anime_loader_file="",
     ))