WeArtController.h

Go to the documentation of this file.

#pragma once
 
#include "CoreMinimal.h"
#include "Sockets.h"
#include "WeArtMessageSerializer.h"
#include "WeArtThimbleTrackingObject.h"
#include "WeArtThimbleSensorObject.h"
#include "WeArtTrackingCalibration.h"
#include "GameFramework/Actor.h"
#include "Kismet/GameplayStatics.h"
#include "WeArtStatusTracker.h"
#include "WeArtCalibrationUX.h"
#include <string>
#include "Containers/Ticker.h"
#include "WeArtController.generated.h"
 
enum WeArtMessageType
{
    MessageSent, MessageReceived
};
 
enum WeArtError
{
    ConnectionError, SendMessageError, ReceiveMessageError
};
 
static char messagesSeparator = '~';
 
UCLASS()
class WEARTPLUGIN_API UWeArtController : public UGameInstanceSubsystem, public FTickableGameObject
{
    GENERATED_BODY()
 
public:
 
    UWeArtController();
    ~UWeArtController();
 
    AWeArtTrackingCalibration* TrackingCalibration;
    AWeArtCalibrationUX* CalibrationUX;
    AWeArtStatusTracker* StatusTracker;
 
    virtual void Initialize(FSubsystemCollectionBase& Collection) override;
    virtual void Deinitialize() override;
 
    UFUNCTION(BlueprintCallable)
        void PauseController();
    UFUNCTION(BlueprintCallable)
        void UnpauseController();
    UFUNCTION(BlueprintCallable)
        void StartCalibration();
    UFUNCTION(BlueprintCallable)
        void StopCalibration();
    UFUNCTION(BlueprintCallable)
        bool GetIsAutoCalibrationOn();
    UFUNCTION(BlueprintCallable)
        bool GetIsAutoRawDataOn();
    UFUNCTION(BlueprintCallable)
        void RequestMiddlewareStatus();
 
    void ScheduleController();
 
    void SendMessage(WeArtMessage* message);
    bool ReceiveMessages(std::vector<WeArtMessage*>& messages);
 
    void OnMessageReceived(WeArtMessage* msg);
    void StopConnection();
 
    void LogMessage(WeArtMessageType type, FString& message);
    void LogError(WeArtError error, FString& message);
 
    void HandleReceivedMessage(FString& message);
    // We are keeping track of attached thimble tracking objects,
    // so we can forward received messages to them. Usually
    // that could be solved via delegates, but native C++
    // has no support for those, and UE4 delegates would require
    // the WeArtMessage object to be an UCLASS for some reason.
    TArray<UWeArtThimbleTrackingObject*> thimbleTrackingObjects;
    TArray<UWeArtThimbleSensorObject*> thimbleSensorObjects;
 
protected:
    UPROPERTY()
        int ClientPort;
 
    UPROPERTY()
        bool DebugMessages;
 
    UPROPERTY()
        bool ControllerAutoStart;
 
    UPROPERTY()
        bool CalibrationAutoStart;
 
    UPROPERTY()
        bool RawDataAutoStart;
 
    bool initialized = false;
    bool foundTrackingCalibration = false;
    bool foundCalibrationUX = false;
    bool foundStatusTracker = false;
    bool isCancellationRequested = false;
    FSocket* socket;
    WeArtMessageSerializer messageSerializer;
    uint8* messageReceivedBuffer[1024];
    std::string trailingText;
    bool IsConnected = false;
    bool IsPaused = false;
 
    void Tick(float DeltaTime) override;
    bool IsTickable() const override;
    bool IsTickableInEditor() const override;
    bool IsTickableWhenPaused() const override;
    TStatId GetStatId() const override;
    UWorld* GetWorld() const override;
};