GameplayDebuggerCategoryReplicator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Class.h"
#include "GameFramework/Actor.h"
#include "GameplayDebuggerTypes.h"
#include "GameplayDebuggerCategoryReplicator.generated.h"
 
class AGameplayDebuggerCategoryReplicator;
class APlayerController;
class FGameplayDebuggerCategory;
class FGameplayDebuggerExtension;
class UGameplayDebuggerRenderingComponent;
 
// Struct used to send the DataPackPackets as RPC`s instead of using the CustomDeltaNetSerializer.
USTRUCT()
struct FGameplayDebuggerDataPackRPCParams
{
    GENERATED_BODY()
 
    UPROPERTY()
    FName CategoryName;
 
    UPROPERTY()
    int32 DataPackIdx = 0;
 
    UPROPERTY()
    FGameplayDebuggerDataPackHeader Header;
 
    UPROPERTY()
    TArray<uint8> Data;
};
 
USTRUCT()
struct FGameplayDebuggerCategoryData
{
    GENERATED_BODY()
 
    UPROPERTY()
    FName CategoryName;
 
    UPROPERTY()
    TArray<FString> TextLines;
 
    UPROPERTY()
    TArray<FGameplayDebuggerShape> Shapes;
 
    // Either replicated using the NetDeltaSerialize or alternatively as regular RPC`s
    UPROPERTY(NotReplicated)
    TArray<FGameplayDebuggerDataPackHeader> DataPacks;
 
    UPROPERTY()
    bool bIsEnabled = false;
};
 
USTRUCT()
struct FGameplayDebuggerNetPack
{
    GENERATED_BODY()
 
    UPROPERTY(NotReplicated)
    TObjectPtr<AGameplayDebuggerCategoryReplicator> Owner;
 
    FGameplayDebuggerNetPack() : Owner(nullptr) {}
 
    bool NetDeltaSerialize(FNetDeltaSerializeInfo & DeltaParms);
    void OnCategoriesChanged();
 
    // When using Iris we cannot use the same appoach as the current NetSerializeDelta as it does polling of data and also modifies data outside of the replicated state during serialization which is not allowed when using iris.
    // Therefore we need explicit methods to populate the state from the owner and to apply it to the owner which can be invoked before and after serialization as needed.
    void PopulateFromOwner();
    void ApplyToOwner();
 
private:
    UPROPERTY()
    TArray<FGameplayDebuggerCategoryData> SavedData;
};
 
template<>
struct TStructOpsTypeTraits<FGameplayDebuggerNetPack> : public TStructOpsTypeTraitsBase2<FGameplayDebuggerNetPack>
{
    enum
    {
        WithNetDeltaSerializer = true,
    };
};
 
USTRUCT()
struct FGameplayDebuggerDebugActor
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TWeakObjectPtr<AActor> Actor;
 
    UPROPERTY()
    FName ActorName;
 
    UPROPERTY()
    int16 SyncCounter = 0;
};
 
USTRUCT()
struct FGameplayDebuggerVisLogSync
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FString DeviceIDs;
};
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FNotifyGameplayDebuggerOwnerChange, AGameplayDebuggerCategoryReplicator*, APlayerController* );
 
UCLASS(NotBlueprintable, NotBlueprintType, notplaceable, noteditinlinenew, hidedropdown, Transient, MinimalAPI)
class AGameplayDebuggerCategoryReplicator : public AActor
{
    GENERATED_UCLASS_BODY()
 
    GAMEPLAYDEBUGGER_API virtual class UNetConnection* GetNetConnection() const override;
    GAMEPLAYDEBUGGER_API virtual bool IsNetRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const FVector& SrcLocation) const override;
 
protected:
    GAMEPLAYDEBUGGER_API virtual void BeginPlay() override;
 
    GAMEPLAYDEBUGGER_API virtual void OnReplicationStartedForIris(const FOnReplicationStartedParams&) override;
 
    GAMEPLAYDEBUGGER_API virtual const AActor* GetNetOwner() const override;
 
public:
    GAMEPLAYDEBUGGER_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    GAMEPLAYDEBUGGER_API virtual void TickActor(float DeltaTime, enum ELevelTick TickType, FActorTickFunction& ThisTickFunction) override;
    GAMEPLAYDEBUGGER_API virtual void PostNetReceive() override;
 
    GAMEPLAYDEBUGGER_API virtual void PreReplication(IRepChangedPropertyTracker& ChangedPropertyTracker) override;
 
    GAMEPLAYDEBUGGER_API void SetReplicatorOwner(APlayerController* InOwnerPC);
    static GAMEPLAYDEBUGGER_API FNotifyGameplayDebuggerOwnerChange NotifyDebuggerOwnerChange;
 
    GAMEPLAYDEBUGGER_API void SetEnabled(bool bEnable);
 
    GAMEPLAYDEBUGGER_API void SetCategoryEnabled(int32 CategoryId, bool bEnable);
 
    GAMEPLAYDEBUGGER_API void SetDebugActor(AActor* Actor, bool bSelectInEditor = false);
 
    GAMEPLAYDEBUGGER_API void SetViewPoint(const FVector& InViewLocation, const FVector& InViewDirection);
 
    bool IsViewPointSet() const { return ViewLocation.IsSet() && ViewDirection.IsSet(); }
 
    GAMEPLAYDEBUGGER_API void ResetViewPoint();
 
    GAMEPLAYDEBUGGER_API void SendCategoryInputEvent(int32 CategoryId, int32 HandlerId);
 
    GAMEPLAYDEBUGGER_API void SendExtensionInputEvent(int32 ExtensionId, int32 HandlerId);
 
    GAMEPLAYDEBUGGER_API void CollectCategoryData(bool bForce = false);
 
    AActor* GetDebugActor() const { return DebugActor.Actor.IsStale() ? nullptr : DebugActor.Actor.Get(); }
    
    FName GetDebugActorName() const { return DebugActor.ActorName; }
 
    int16 GetDebugActorCounter() const { return DebugActor.SyncCounter; }
 
    GAMEPLAYDEBUGGER_API bool GetViewPoint(FVector& OutViewLocation, FVector& OutViewDirection) const;
 
    const FGameplayDebuggerVisLogSync& GetVisLogSyncData() const { return VisLogSync; }
 
    TObjectPtr<APlayerController> GetReplicationOwner() const { return OwnerPC; }
 
    bool IsEnabled() const { return bIsEnabled; }
 
    bool IsEditorWorldReplicator() const { return bIsEditorWorldReplicator; }
 
    GAMEPLAYDEBUGGER_API bool IsCategoryEnabled(int32 CategoryId) const;
 
    bool HasDebugActor() const { return DebugActor.ActorName != NAME_None; }
 
    int32 GetNumCategories() const { return Categories.Num(); }
 
    int32 GetNumExtensions() const { return Extensions.Num(); }
 
    TSharedRef<FGameplayDebuggerCategory> GetCategory(int32 CategoryId) const { return Categories[CategoryId]; }
 
    TSharedRef<FGameplayDebuggerExtension> GetExtension(int32 ExtensionId) const { return Extensions[ExtensionId]; }
 
    bool IsLocal() const { return bIsLocal; }
 
#if WITH_EDITOR
    GAMEPLAYDEBUGGER_API void InitForEditor();
#endif // WITH_EDITOR
 
protected:
    UFUNCTION()
    GAMEPLAYDEBUGGER_API void OnRep_ReplicatedData();
 
 
    friend FGameplayDebuggerNetPack;
 
    UPROPERTY(Replicated)
    TObjectPtr<APlayerController> OwnerPC;
 
    UPROPERTY(Replicated)
    bool bIsEnabled;
 
    UPROPERTY(Replicated, ReplicatedUsing=OnRep_ReplicatedData)
    FGameplayDebuggerNetPack ReplicatedData;
 
    UPROPERTY(Replicated)
    FGameplayDebuggerDebugActor DebugActor;
 
    UPROPERTY(Replicated)
    FGameplayDebuggerVisLogSync VisLogSync;
 
    UPROPERTY()
    TObjectPtr<UGameplayDebuggerRenderingComponent> RenderingComp;
 
    TArray<TSharedRef<FGameplayDebuggerCategory> > Categories;
 
    TArray<TSharedRef<FGameplayDebuggerExtension> > Extensions;
 
    TOptional<FVector> ViewLocation;
    TOptional<FVector> ViewDirection;
 
    uint32 bIsEnabledLocal : 1;
    uint32 bHasAuthority : 1;
    uint32 bIsLocal : 1;
    uint32 bIsEditorWorldReplicator : 1;
    uint32 bSendDataPacksUsingRPC : 1;
 
    GAMEPLAYDEBUGGER_API void OnCategoriesChanged();
 
    GAMEPLAYDEBUGGER_API void OnExtensionsChanged();
 
    GAMEPLAYDEBUGGER_API void NotifyCategoriesToolState(bool bIsActive);
 
    GAMEPLAYDEBUGGER_API void NotifyExtensionsToolState(bool bIsActive);
 
    UFUNCTION(Server, Reliable, WithValidation, meta = (CallInEditor = "true"))
    GAMEPLAYDEBUGGER_API void ServerSetEnabled(bool bEnable);
 
    UFUNCTION(Server, Reliable, WithValidation, meta = (CallInEditor = "true"))
    GAMEPLAYDEBUGGER_API void ServerSetDebugActor(AActor* Actor, bool bSelectInEditor);
 
    UFUNCTION(Server, Reliable, WithValidation, meta = (CallInEditor = "true"))
    GAMEPLAYDEBUGGER_API void ServerSetViewPoint(const FVector& InViewLocation, const FVector& InViewDirection);
 
    UFUNCTION(Server, Reliable, WithValidation, meta = (CallInEditor = "true"))
    GAMEPLAYDEBUGGER_API void ServerResetViewPoint();
 
    UFUNCTION(Server, Reliable, WithValidation, meta = (CallInEditor = "true"))
    GAMEPLAYDEBUGGER_API void ServerSetCategoryEnabled(int32 CategoryId, bool bEnable);
 
    UFUNCTION(Server, Reliable, WithValidation, meta = (CallInEditor = "true"))
    GAMEPLAYDEBUGGER_API void ServerSendCategoryInputEvent(int32 CategoryId, int32 HandlerId);
 
    UFUNCTION(Server, Reliable, WithValidation, meta = (CallInEditor = "true"))
    GAMEPLAYDEBUGGER_API void ServerSendExtensionInputEvent(int32 ExtensionId, int32 HandlerId);
 
    UFUNCTION(Client, Reliable)
    GAMEPLAYDEBUGGER_API void ClientDataPackPacket(const FGameplayDebuggerDataPackRPCParams& Params);
    
    GAMEPLAYDEBUGGER_API void OnReceivedDataPackPacket(int32 CategoryId, int32 DataPackId, const FGameplayDebuggerDataPack& DataPacket);
 
    GAMEPLAYDEBUGGER_API void Init();
 
private:
    GAMEPLAYDEBUGGER_API void SendDataPackPacket(FName CategoryName, int32 DataPackIdx, FGameplayDebuggerDataPack& DataPack);
};