BufferedData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
// HEADER_UNIT_SKIP - Internal
 
namespace Chaos
{
    template<typename DataType>
    class TBufferedData
    {
    public:
 
        TBufferedData()
            : SyncCounter(0)
            , BufferIndex(0)
        {
            DataSyncCounts[0] = 0;
            DataSyncCounts[1] = 0;
        }
 
        void Flip()
        {
            BufferIndex.Store(GetGameDataIndex());
        }
 
        const DataType& GetGameDataForRead() const
        {
            return Data[GetGameDataIndex()];
        }
 
        const DataType& GetPhysicsDataForRead() const
        {
            return Data[GetPhysicsDataIndex()];
        }
 
        int32 GetGameDataSyncCount() const 
        {
            return DataSyncCounts[GetGameDataIndex()];
        }
 
        int32 GetPhysicsDataSyncCount() const
        {
            return DataSyncCounts[GetPhysicsDataIndex()];
        }
 
        DataType& GetGameDataForWrite()
        {
            return Data[GetGameDataIndex()];
        }
 
        DataType& GetPhysicsDataForWrite()
        {
            int32 DataIndex = GetPhysicsDataIndex();
            DataSyncCounts[DataIndex] = ++SyncCounter;
            return Data[DataIndex];
        }
 
        DataType& Get(int32 InIndex)
        {
            checkSlow(InIndex == 0 || InIndex == 1);
            return Data[InIndex];
        }
 
    private:
 
        int32 GetPhysicsDataIndex() const
        {
            return BufferIndex.Load();
        }
 
        int32 GetGameDataIndex() const
        {
            return GetPhysicsDataIndex() == 1 ? 0 : 1;
        }
 
        // Counter used to identify writes
        uint32 SyncCounter;
        // Counter values for each side of the buffer
        uint32 DataSyncCounts[2];
 
        // Atomic index for accessing the buffer sides
        TAtomic<int32> BufferIndex;
 
        // The actual data type stored
        DataType Data[2];
    };
 
    template<typename ResourceType>
    class TChaosReadWriteResource
    {
    public:
 
        template<typename... ArgTypes>
        TChaosReadWriteResource(EInPlace, ArgTypes&&... Args)
            : ResourceLock()
            , Buffer{{Args...},{Forward<ArgTypes>(Args)...}}
            , ReadIndex(0)
        {}
 
        void Swap()
        {
            ResourceLock.WriteLock();
 
            ReadIndex = (ReadIndex + 1) % 2;
 
            ResourceLock.WriteUnlock();
        }
 
        const ResourceType& GetRead() const
        {
            ResourceLock.ReadLock();
            return Buffer[ReadIndex];
        }
 
        void ReleaseRead() const
        {
            ResourceLock.ReadUnlock();
        }
 
        ResourceType& GetWritable()
        {
            return Buffer[(ReadIndex + 1) % 2];
        }
        const ResourceType& GetReadable() const
        {
            return Buffer[(ReadIndex + 1) % 2];
        }
 
    private:
 
        mutable FRWLock ResourceLock;
 
        ResourceType Buffer[2];
 
        int32 ReadIndex;
    };
}