Channel.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/Object.h"
#include "UObject/CoreNet.h"
#include "HAL/LowLevelMemTracker.h"
#include "Channel.generated.h"
 
LLM_DECLARE_TAG_API(NetChannel, ENGINE_API);
 
class FInBunch;
class FOutBunch;
class UNetConnection;
 
// Constant for all buffers that are reading from the network
inline const int MAX_STRING_SERIALIZE_SIZE  = NAME_SIZE;
 
enum EChannelType
{
    CHTYPE_None         = 0,  // Invalid type.
    CHTYPE_Control      = 1,  // Connection control.
    CHTYPE_Actor        = 2,  // Actor-update channel.
 
    // @todo: Remove and reassign number to CHTYPE_Voice (breaks net compatibility)
    CHTYPE_File         = 3,  // Binary file transfer.
 
    CHTYPE_Voice        = 4,  // VoIP data channel
    CHTYPE_MAX          = 8,  // Maximum.
};
 
enum class EChannelCreateFlags : uint32
{
    None            = (1 << 0),
    OpenedLocally   = (1 << 1)
};
ENUM_CLASS_FLAGS(EChannelCreateFlags);
 
enum class EChannelGetAdditionalRequiredBunchesFlags : uint32
{
    None                = 0U,
    SkipNetGUIDExports  = 1U
};
ENUM_CLASS_FLAGS(EChannelGetAdditionalRequiredBunchesFlags);
 
// The channel index to use for voice
#define VOICE_CHANNEL_INDEX 1
 
 
UCLASS(abstract, transient, MinimalAPI)
class UChannel : public UObject
{
    GENERATED_BODY()
    
public:
    UPROPERTY()
    TObjectPtr<class UNetConnection>    Connection;     // Owner connection.
 
    // Variables.
    uint32              OpenAcked:1;        // If OpenedLocally is true, this means we have acknowledged the packet we sent the bOpen bunch on. Otherwise, it means we have received the bOpen bunch from the server.
    uint32              Closing:1;          // State of the channel.
    uint32              Dormant:1;          // Channel is going dormant (it will close but the client will not destroy
    UE_DEPRECATED(5.3, "Replication pausing is deprecated and will be removed")
    uint32              bIsReplicationPaused:1; // Replication is being paused, but channel will not be closed
    uint32              OpenTemporary:1;    // Opened temporarily.
    uint32              Broken:1;           // Has encountered errors and is ignoring subsequent packets.
    uint32              bTornOff:1;         // Actor associated with this channel was torn off
    uint32              bPendingDormancy:1; // Channel wants to go dormant (it will check during tick if it can go dormant)
    uint32              bIsInDormancyHysteresis:1; // Channel wants to go dormant, and is otherwise ready to become dormant, but is waiting for a timeout before doing so.
    uint32              bPausedUntilReliableACK:1; // Unreliable property replication is paused until all reliables are ack'd.
    uint32              SentClosingBunch:1; // Set when sending closing bunch to avoid recursion in send-failure-close case.
    uint32              bPooled:1;          // Set when placed in the actor channel pool
    uint32              OpenedLocally:1;    // Whether channel was opened locally or by remote.
    uint32              bOpenedForCheckpoint:1; // Whether channel was opened by replay checkpoint recording
    int32               ChIndex;            // Index of this channel.
    FPacketIdRange      OpenPacketId;       // If OpenedLocally is true, this is the packet we sent the bOpen bunch on. Otherwise, it's the packet we received the bOpen bunch on.
    FName               ChName;             // Name of the type of this channel.
    int32               NumInRec;           // Number of packets in InRec.
    int32               NumOutRec;          // Number of packets in OutRec.
    class FInBunch*     InRec;              // Incoming data with queued dependencies.
    class FOutBunch*    OutRec;             // Outgoing reliable unacked data.
    class FInBunch*     InPartialBunch;     // Partial bunch we are receiving (incoming partial bunches are appended to this)
 
    // UObject overrides
 
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
 
    ENGINE_API virtual void Init(UNetConnection* InConnection, int32 InChIndex, EChannelCreateFlags CreateFlags);
 
    virtual void ReInit() {}
 
    ENGINE_API virtual void SetClosingFlag();
 
    ENGINE_API virtual int64 Close(EChannelCloseReason Reason);
 
    ENGINE_API virtual FString Describe();
 
    virtual void ReceivedBunch( FInBunch& Bunch ) PURE_VIRTUAL(UChannel::ReceivedBunch,);
    
    ENGINE_API virtual void ReceivedAck( int32 AckPacketId );
 
    ENGINE_API virtual void ReceivedNak( int32 NakPacketId );
    
    ENGINE_API virtual void Tick();
 
    virtual bool CanStopTicking() const { return !bPendingDormancy; }
 
    // General channel functions.
    ENGINE_API bool ReceivedAcks(EChannelCloseReason& OutCloseReason);
 
    ENGINE_API void ReceivedAcks();
    
    ENGINE_API bool ReceivedSequencedBunch( FInBunch& Bunch );
    
    ENGINE_API void ReceivedRawBunch( FInBunch & Bunch, bool & bOutSkipAck );
 
    UE_DEPRECATED(5.5, "Use GetAdditionalRequiredBunches")
    ENGINE_API virtual void AppendExportBunches(TArray< FOutBunch* >& OutExportBunches);
 
    ENGINE_API virtual TArray<FOutBunch*> GetAdditionalRequiredBunches(const FOutBunch& OutgoingBunch, EChannelGetAdditionalRequiredBunchesFlags Flags = EChannelGetAdditionalRequiredBunchesFlags::None);
 
    ENGINE_API virtual void AppendMustBeMappedGuids( FOutBunch* Bunch );
 
    ENGINE_API virtual FPacketIdRange SendBunch(FOutBunch* Bunch, bool Merge);
    
    UE_DEPRECATED(5.6, "Replaced with a version that doesn't have a saturate option.")
    ENGINE_API int32 IsNetReady( bool Saturate );
 
    ENGINE_API bool IsNetReady() const;
 
    ENGINE_API void AssertInSequenced();
 
    ENGINE_API void ConditionalCleanUp(const bool bForDestroy, EChannelCloseReason CloseReason);
 
    virtual bool ReadyForDormancy(bool suppressLogs=false) { return false; }
 
    virtual void StartBecomingDormant() { }
 
    UE_DEPRECATED(5.3, "Will be removed from test/shipping in the future.")
    ENGINE_API void PrintReliableBunchBuffer();
 
    /* Notification that this channel has been placed in a channel pool and needs to reset to its original state so it can be used again like a new channel */
    ENGINE_API virtual void AddedToChannelPool();
 
    ENGINE_API virtual bool HasAcknowledgedAllReliableData() const;
 
protected:
 
    virtual void BecomeDormant() { }
 
    ENGINE_API virtual bool CleanUp( const bool bForDestroy, EChannelCloseReason CloseReason );
 
    UE_DEPRECATED(5.3, "Replication pausing is deprecated and will be removed")
    virtual void SetReplicationPaused(bool InbIsReplicationPaused) 
    { 
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        bIsReplicationPaused = InbIsReplicationPaused;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.3, "Replication pausing is deprecated and will be removed")
    virtual bool IsReplicationPaused() 
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return bIsReplicationPaused; 
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
private:
 
    ENGINE_API int32 SendRawBunch(FOutBunch* Bunch, bool Merge, const FNetTraceCollector* Collector = nullptr);
 
    ENGINE_API FOutBunch* PrepBunch(FOutBunch* Bunch, FOutBunch* OutBunch, bool Merge);
 
    ENGINE_API bool ReceivedNextBunch( FInBunch & Bunch, bool & bOutSkipAck );
};