write shit

BasaltPresenter/Presenter/CMakeLists.txt

@@ -3,12 +3,14 @@ target_sources(BasaltPresenter
 PRIVATE
     main.cpp
     dll_loader.cpp
+    command_client.cpp
 )
 target_sources(BasaltPresenter
 PUBLIC
 FILE_SET HEADERS
 FILES
     dll_loader.hpp
+    command_client.hpp
 )
 target_include_directories(BasaltPresenter
 PUBLIC

BasaltPresenter/Presenter/command_client.cpp

@@ -0,0 +1,78 @@
+#include "command_client.hpp"
+#include <stdexcept>
+
+namespace Basalt::Presenter {
+
+    CommandClient::CommandClient(const std::basic_string_view<BSCHAR> pipe_name)
+        : m_PipeOperator(pipe_name) {
+    }
+
+    CommandClient::~CommandClient() {
+    }
+
+    void CommandClient::WaitHandshake(std::uint8_t pixel_kind, std::uint32_t width, std::uint32_t height) {
+        if (m_Handshaked) {
+            throw std::runtime_error("Handshake already completed");
+        }
+
+        // Wait for handshake request from Trainer (code 0x61)
+        std::uint8_t received_code;
+        m_PipeOperator.Read(&received_code, sizeof(received_code));
+
+        if (received_code != HANDSHAKE_CODE_REQUEST) {
+            throw std::runtime_error("Expected handshake code 0x61, got 0x" + 
+                                   std::to_string(static_cast<int>(received_code)));
+        }
+
+        // Send handshake response (code 0x62) back to Trainer
+        std::uint8_t handshake_response = HANDSHAKE_CODE_RESPONSE;
+        m_PipeOperator.Write(&handshake_response, sizeof(handshake_response));
+
+        // Send data properties after handshake
+        m_PipeOperator.Write(&pixel_kind, sizeof(pixel_kind));
+        m_PipeOperator.Write(&width, sizeof(width));
+        m_PipeOperator.Write(&height, sizeof(height));
+
+        m_Handshaked = true;
+    }
+
+    bool CommandClient::Tick(bool actively_stop) {
+        if (!m_Handshaked) {
+            throw std::runtime_error("Handshake must be completed before calling Tick");
+        }
+
+        // If actively_stop is true, send actively stop code to Trainer
+        if (actively_stop) {
+            std::uint8_t stop_code = ACTIVELY_STOP_CODE;
+            m_PipeOperator.Write(&stop_code, sizeof(stop_code));
+        }
+
+        // Send data ready code to Trainer
+        std::uint8_t data_ready_code = DATA_READY_CODE;
+        m_PipeOperator.Write(&data_ready_code, sizeof(data_ready_code));
+
+        // Wait for response from Trainer
+        std::uint8_t received_code;
+        m_PipeOperator.Read(&received_code, sizeof(received_code));
+
+        // Handle the received code
+        if (received_code == DATA_RECEIVED_CODE) {
+            // Normal response, continue processing
+            return false; // Not stopping
+        } else if (received_code == STOP_CODE) {
+            // Trainer wants to stop
+            return true; // Should stop
+        } else if (received_code == HANDSHAKE_CODE_REQUEST || received_code == HANDSHAKE_CODE_RESPONSE) {
+            // Unexpected handshake code during Tick
+            throw std::runtime_error("Unexpected handshake code 0x" + 
+                                   std::to_string(static_cast<int>(received_code)) + 
+                                   " received during Tick operation");
+        } else {
+            // Unknown code
+            throw std::runtime_error("Unknown code 0x" + 
+                                   std::to_string(static_cast<int>(received_code)) + 
+                                   " received during Tick operation");
+        }
+    }
+
+} // namespace Basalt::Presenter

BasaltPresenter/Presenter/command_client.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <basalt/pipe_operator.hpp>
+#include <cstdint>
+
+namespace Basalt::Presenter {
+
+    class CommandClient {
+    public:
+        // Protocol codes
+        static constexpr std::uint8_t HANDSHAKE_CODE_REQUEST = 0x61;  // Trainer -> Presenter
+        static constexpr std::uint8_t HANDSHAKE_CODE_RESPONSE = 0x62; // Presenter -> Trainer
+        static constexpr std::uint8_t DATA_READY_CODE = 0x01;         // Presenter -> Trainer
+        static constexpr std::uint8_t DATA_RECEIVED_CODE = 0x02;      // Trainer -> Presenter
+        static constexpr std::uint8_t ACTIVELY_STOP_CODE = 0x71;      // Both directions
+        static constexpr std::uint8_t STOP_CODE = 0x71;               // Both directions (same code)
+
+        // Pixel kind values
+        static constexpr std::uint8_t PIXEL_GRAY_FLOAT32 = 0x01;      // Grayscale represented by one float32
+        static constexpr std::uint8_t PIXEL_GRAY_U8 = 0x02;           // Grayscale represented by one u8
+        static constexpr std::uint8_t PIXEL_RGB_FLOAT32 = 0x03;       // RGB represented by three float32
+        static constexpr std::uint8_t PIXEL_RGB_U8 = 0x04;            // RGB represented by three u8
+
+        CommandClient(const std::basic_string_view<BSCHAR> pipe_name = BSTEXT("ed0e3f1f-d214-4880-9562-640bce15e72e"));
+        ~CommandClient();
+
+        // Wait for handshake from Trainer, send response with data properties
+        void WaitHandshake(std::uint8_t pixel_kind, std::uint32_t width, std::uint32_t height);
+
+        // Tick function called every frame to send data ready and wait for response
+        bool Tick(bool actively_stop = false);
+
+    private:
+        Basalt::Shared::PipeOperator m_PipeOperator;
+        bool m_Handshaked = false;  // Track handshake state
+    };
+
+} // namespace Basalt::Presenter