TimeSynchronizationSource.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
 
#include "Misc/QualifiedFrameTime.h"
#include "Misc/FrameRate.h"
#include "Misc/FrameTime.h"
#include "Misc/Timecode.h"
 
#include "Templates/SharedPointer.h"
 
#include "TimeSynchronizationSource.generated.h"
 
#if WITH_EDITOR
class SWidget;
#endif
 
struct FTimeSynchronizationOpenData
{
    FFrameRate SynchronizationFrameRate;
 
    TOptional<FFrameTime> RolloverFrame;
};
 
struct FTimeSynchronizationStartData
{
    FFrameTime StartFrame;
};
 
UCLASS(Abstract, MinimalAPI)
class UTimeSynchronizationSource : public UObject
{
    GENERATED_UCLASS_BODY()
 
public:
 
    UPROPERTY(EditAnywhere, Category = Synchronization)
    bool bUseForSynchronization;
 
    UPROPERTY(EditAnywhere, Category = Synchronization)
    int32 FrameOffset;
 
public:
 
#if WITH_EDITOR
    TIMEMANAGEMENT_API virtual TSharedRef<SWidget> GetVisualWidget() const;
#endif
 
    virtual FFrameTime GetNewestSampleTime() const PURE_VIRTUAL(UTimeSynchronizationSource::GetNewestSampleTime, return FFrameTime();)
 
    virtual FFrameTime GetOldestSampleTime() const PURE_VIRTUAL(UTimeSynchronizationSource::GetOldestSampleTime, return FFrameTime();)
 
    virtual FFrameRate GetFrameRate() const PURE_VIRTUAL(UTimeSynchronizationSource::GetFrameRate, return FFrameRate();)
 
    virtual bool IsReady() const PURE_VIRTUAL(UTimeSynchronizationSource::IsReady, return false;)
 
    virtual bool Open(const FTimeSynchronizationOpenData& OpenData) PURE_VIRTUAL(UTimeSynchronizationSource::Open, return false;)
 
    virtual void Start(const FTimeSynchronizationStartData& StartData) PURE_VIRTUAL(UTimeSynchronizationSource::Start, return;)
 
    virtual void Close() PURE_VIRTUAL(UTimeSynchronizationSource::Close, return;)
 
    virtual FString GetDisplayName() const PURE_VIRTUAL(UTimeSynchronizationSource::GetDisplayName, return FString();)
 
public:
 
    inline static bool IsFrameBetweenWithRolloverModulus(const FFrameTime& ToCheck, const FFrameTime& LowerBound, const FFrameTime& UpperBound, const FFrameTime& RolloverModulus)
    {
        if (LowerBound <= UpperBound)
        {
            return LowerBound <= ToCheck && ToCheck <= UpperBound;
        }
        else
        {
            return (LowerBound <= ToCheck && ToCheck <= RolloverModulus) || (FFrameTime(0) <= ToCheck && ToCheck <= UpperBound);
        }
    }
 
    inline static FTimecode ConvertFrameTimeToTimecode(const FFrameTime& FrameTime, const FFrameRate& FrameRate)
    {
        return FTimecode::FromFrameNumber(FrameTime.GetFrame(), FrameRate);
    }
 
    inline static FFrameTime AddOffsetWithRolloverModulus(const FFrameTime& FrameTime, const int32 Offset, const FFrameTime& RolloverModulus)
    {
        const FFrameTime WithOffset = FrameTime + Offset;
        const int32 RolloverFrameValue = RolloverModulus.GetFrame().Value;
        return FFrameTime((WithOffset.GetFrame().Value + RolloverFrameValue) % RolloverFrameValue, WithOffset.GetSubFrame());
    }
 
    static int32 FindDistanceBetweenFramesWithRolloverModulus(const FFrameTime& StartFrameTime, const FFrameTime& EndFrameTime, const TOptional<FFrameTime>& RolloverModulus, bool& bDidRollover)
    {
        int32 Offset = (EndFrameTime.GetFrame().Value - StartFrameTime.GetFrame().Value);
        bDidRollover = false;
 
        if (RolloverModulus.IsSet())
        {
            // At this point, we don't know if a rollover has occurred.
            // Any comparisons will be useless, because we don't know the real order.
 
            // If we assume the "real world" distance between these frames is usually small, then
            // we can figure out ordering based on distance.
            // Here, we'll define relatively small as being less than half the time of our roll over range.
            // That is, if we roll over every 24 hours, "small" will be 12 hours or less.
            // The reason for this choice is because if 2 values are half the roll over distance apart,
            // they are equidistant in modulo space. Anything greater than half implies
            // that a roll over has occurred, while anything less than half implies no roll over. 
 
            const int32 RolloverTimeValue = RolloverModulus->GetFrame().Value;
 
            if (FMath::Abs(Offset) > (RolloverTimeValue / 2))
            {
                // At this point, we know that a roll over has occurred between the frames.
                // If Offset is negative, then Start was greater than End, we'll assume the roll over happened between then, and our output should be positive.
                // If Offset is positive, the inverse is true (and our output will be negative).
                // To correct for that, we need to "unroll" modulo space by adding or subtracting
                // the full rollover value.
 
                Offset += (Offset < 0) ? RolloverTimeValue : -RolloverTimeValue;
                bDidRollover = true;
            }
        }
 
        return Offset;
    }
};