finish representer protocol

BasaltPresenter/Presenter/cmd_client.cpp

@@ -1,5 +1,4 @@
 #include "cmd_client.hpp"
-#include <basalt/char_types.hpp>
 #include <stdexcept>
 
 namespace basalt::presenter::cmd_client {
@@ -21,7 +20,20 @@ namespace basalt::presenter::cmd_client {
         }
         // Accept payload
         HandshakePayload handshake_payload;
-        m_PipeOperator.read_pod(handshake_payload);
+        std::uint8_t raw_headless;
+        m_PipeOperator.read_pod(raw_headless);
+        handshake_payload.headless = static_cast<bool>(raw_headless);
+        m_PipeOperator.read_pod(handshake_payload.pixel_kind);
+        m_PipeOperator.read_pod(handshake_payload.width);
+        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_pod(handshake_payload.delivery_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);
+        m_PipeOperator.read_bsstring(handshake_payload.anime_loader_file);
 
         // Send handshake response (code 0x62) back to Trainer
         ProtocolCode response_code = ProtocolCode::HANDSHAKE_RESPONSE;

BasaltPresenter/Presenter/cmd_client.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <basalt/char_types.hpp>
 #include <basalt/pipe_operator.hpp>
 #include <cstdint>
 
@@ -23,13 +24,20 @@ namespace basalt::presenter::cmd_client {
         RGB_U8 = 0x04        ///< RGB represented by three u8
     };
 
-#pragma pack(push, 1)
     struct HandshakePayload {
+        bool headless;
         PixelKind pixel_kind;
         std::uint32_t width;
         std::uint32_t height;
+        shared::char_types::BSString engine_name;
+        std::uint32_t engine_device;
+        shared::char_types::BSString delivery_name;
+        std::uint32_t delivery_device;
+        shared::char_types::BSString object_loader_name;
+        shared::char_types::BSString object_loader_file;
+        shared::char_types::BSString anime_loader_name;
+        shared::char_types::BSString anime_loader_file;
     };
-#pragma pack(pop)
 
     // Status
     enum class CmdClientStatus {

BasaltPresenter/Presenter/main.cpp

@@ -21,13 +21,20 @@ using ::basalt::presenter::cmd_client::CmdClient;
 using ::basalt::presenter::stopwatch::Stopwatch;
 
 int main(int argc, char* argv[]) {
-    spdlog::info("Finding plugins...");
-    auto engine_dll = DllLoader(DllKind::Engine, BSTEXT("BasaltDirectX11Engine"));
-    auto deliver_dll = DllLoader(DllKind::Deliver, BSTEXT("BasaltPipeDeliver"));
-
     auto client = CmdClient();
     spdlog::info("Waiting BasaltTrainer...");
     auto payload = client.wait_handshake();
+    spdlog::info("BasaltTrainer Requirements:");
+    spdlog::info(BSTEXT("\tEngine: {}"), payload.engine_name);
+    spdlog::info(BSTEXT("\tDeliver: {}"), payload.delivery_name);
+    spdlog::info(BSTEXT("\tObject Loader: {}"), payload.object_loader_name);
+    spdlog::info(BSTEXT("\tAnime Loader: {}"), payload.anime_loader_name);
+
+    spdlog::info("Finding plugins...");
+    auto engine_dll = DllLoader(DllKind::Engine, payload.engine_name);
+    auto deliver_dll = DllLoader(DllKind::Deliver, payload.delivery_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...");
     auto* engine = engine_dll.create_instance<IEngine>();

BasaltPresenter/Shared/basalt/pipe_operator.hpp

@@ -44,14 +44,30 @@ namespace basalt::shared::pipe_operator {
             write(&buffer, sizeof(TPod));
         }
         void read_string(std::string& buffer) {
-            size_t length = 0;
+            std::uint32_t raw_length = 0;
-            read_pod(length);
+            read_pod(raw_length);
+            auto length = static_cast<std::size_t>(raw_length);
             buffer.resize(length);
-            read(buffer.data(), length);
+            read(buffer.data(), length * sizeof(std::string::value_type));
         }
-        void write_string(std::string_view& buffer) {
+        void write_string(const std::string_view& buffer) {
-            write_pod(buffer.size());
+            auto length = buffer.size();
-            write(buffer.data(), buffer.size());
+            auto raw_length = static_cast<std::uint32_t>(length);
+            write_pod(raw_length);
+            write(buffer.data(),length * sizeof(std::string_view::value_type));
+        }
+        void read_bsstring(char_types::BSString& buffer) {
+            std::uint32_t raw_length = 0;
+            read_pod(raw_length);
+            auto length = static_cast<std::size_t>(raw_length);
+            buffer.resize(length);
+            read(buffer.data(), length * sizeof(char_types::BSString::value_type));
+        }
+        void write_bsstring(const char_types::BSStringView& buffer) {
+            auto length = buffer.size();
+            auto raw_length = static_cast<std::uint32_t>(length);
+            write_pod(raw_length);
+            write(buffer.data(), length * sizeof(char_types::BSStringView::value_type));
         }
 
     private:

BasaltTrainer/cmd_server.py

@@ -49,7 +49,6 @@ class ServerStatus(Enum):
 CODE_PACKER: struct.Struct = struct.Struct("=B")
 U8_PACKER: struct.Struct = struct.Struct("=B")
 U32_PACKER: struct.Struct = struct.Struct("=I")
-USIZE_PACKER: struct.Struct = struct.Struct("=N")
 
 
 class CmdServer:
@@ -84,9 +83,9 @@ class CmdServer:
         self.__pipe_operator.write_pod(U32_PACKER, payload.width)
         self.__pipe_operator.write_pod(U32_PACKER, payload.height)
         self.__pipe_operator.write_bsstring(payload.engine_name)
-        self.__pipe_operator.write_pod(USIZE_PACKER, payload.engine_device)
+        self.__pipe_operator.write_pod(U32_PACKER, payload.engine_device)
         self.__pipe_operator.write_bsstring(payload.deliver_name)
-        self.__pipe_operator.write_pod(USIZE_PACKER, payload.deliver_device)
+        self.__pipe_operator.write_pod(U32_PACKER, payload.deliver_device)
         self.__pipe_operator.write_bsstring(payload.object_loader_name)
         self.__pipe_operator.write_bsstring(payload.object_loader_file)
         self.__pipe_operator.write_bsstring(payload.anime_loader_name)

BasaltTrainer/pipe_operator.py

@@ -160,7 +160,7 @@ class PipeOperator:
     def write_pod(self, pattern: struct.Struct, *args) -> None:
         self.write(pattern.pack(*args))
 
-    STR_LEN_PACKER: ClassVar[struct.Struct] = struct.Struct("=N")
+    STR_LEN_PACKER: ClassVar[struct.Struct] = struct.Struct("=I")
 
     def read_string(self) -> str:
         (length,) = self.read_pod(PipeOperator.STR_LEN_PACKER)
@@ -174,22 +174,28 @@ class PipeOperator:
 
     def read_bsstring(self) -> str:
         (length,) = self.read_pod(PipeOperator.STR_LEN_PACKER)
-        str_bytes = self.read(length)
+        str_bytes = self.read(length * 2)
         return self.__decode_bsstring(str_bytes)
 
     def write_bsstring(self, s: str) -> None:
         str_bytes = self.__encode_bsstring(s)
-        self.write_pod(PipeOperator.STR_LEN_PACKER, len(str_bytes))
+        self.write_pod(PipeOperator.STR_LEN_PACKER, len(str_bytes) // 2)
         self.write(str_bytes)
 
     def __encode_bsstring(self, s: str) -> bytes:
-        if IS_LITTLE_ENDIAN:
+        if IS_WINDOWS:
-            return s.encode("utf_16_le")
+            if IS_LITTLE_ENDIAN:
+                return s.encode("utf_16_le")
+            else:
+                return s.encode("utf_16_be")
         else:
-            return s.encode("utf_16_be")
+            return s.encode("utf-8")
 
     def __decode_bsstring(self, b: bytes) -> str:
-        if IS_LITTLE_ENDIAN:
+        if IS_WINDOWS:
-            return b.decode("utf_16_le")
+            if IS_LITTLE_ENDIAN:
+                return b.decode("utf_16_le")
+            else:
+                return b.decode("utf_16_be")
         else:
-            return b.decode("utf_16_be")
+            return b.decode("utf-8")

Document/PROTOCOL.md

@@ -12,7 +12,7 @@ I will introduce them in there about how to transmit them.
 
 ### String
 
-When transmitting string, it will transmit an `usize` at first to indicate the length of string in **character**, NOT in **byte**.
+When transmitting string, it will transmit an `u32` at first to indicate the length of string in **character**, NOT in **byte**.
 Then we transmit the string itself without NULL terminator.
 All transmitted string is UTF-8.