MovieScenePreAnimatedStateTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/Array.h"
#include "Templates/TypeHash.h"
#include "EntitySystem/MovieSceneSequenceInstanceHandle.h"
#include "Evaluation/PreAnimatedState/MovieScenePreAnimatedStorageID.h"
 
namespace UE
{
namespace MovieScene
{
 
struct FEntityAllocationProxy;
 
struct FPreAnimatedTrackerParams
{
    MOVIESCENE_API FPreAnimatedTrackerParams(FEntityAllocationProxy Item);
 
    int32 Num;
    bool bWantsRestoreState;
};
 
struct FCachePreAnimatedValueParams
{
    bool bForcePersist = false;
};
 
enum class EPreAnimatedStorageRequirement : uint8
{
    None,
    Persistent,
    Transient,
 
    NoChange,
};
 
 
struct FPreAnimatedStorageIndex
{
    FPreAnimatedStorageIndex()
        : Value(INDEX_NONE)
    {}
 
    FPreAnimatedStorageIndex(int32 InNewValue)
        : Value(InNewValue)
    {}
 
    FPreAnimatedStorageIndex& operator=(int32 InNewValue)
    {
        Value = InNewValue;
        return *this;
    }
 
    bool IsValid() const
    {
        return Value != INDEX_NONE;
    }
 
    explicit operator bool() const
    {
        return Value != INDEX_NONE;
    }
 
    operator int32() const
    {
        check(Value != INDEX_NONE);
        return Value;
    }
 
    friend uint32 GetTypeHash(const FPreAnimatedStorageIndex& InIndex)
    {
        return ::GetTypeHash(InIndex.Value);
    }
    friend bool operator==(const FPreAnimatedStorageIndex& A, const FPreAnimatedStorageIndex& B)
    {
        return A.Value == B.Value;
    }
 
    int32 Value;
};
 
struct FPreAnimatedStorageGroupHandle
{
    FPreAnimatedStorageGroupHandle()
        : Value(INDEX_NONE)
    {}
 
    FPreAnimatedStorageGroupHandle(int32 InNewValue)
        : Value(InNewValue)
    {}
 
    FPreAnimatedStorageGroupHandle& operator=(int32 InNewValue)
    {
        Value = InNewValue;
        return *this;
    }
 
    bool IsValid() const
    {
        return Value != INDEX_NONE;
    }
 
    explicit operator bool() const
    {
        return Value != INDEX_NONE;
    }
 
    operator int32() const
    {
        check(Value != INDEX_NONE);
        return Value;
    }
 
    friend uint32 GetTypeHash(const FPreAnimatedStorageGroupHandle& InHandle)
    {
        return ::GetTypeHash(InHandle.Value);
    }
    friend bool operator==(const FPreAnimatedStorageGroupHandle& A, const FPreAnimatedStorageGroupHandle& B)
    {
        return A.Value == B.Value;
    }
 
    int32 Value;
};
 
 
struct FPreAnimatedStateCachedValueHandle
{
    FPreAnimatedStorageID TypeID;
 
    FPreAnimatedStorageIndex StorageIndex;
 
    friend uint32 GetTypeHash(const FPreAnimatedStateCachedValueHandle& InEntry)
    {
        return GetTypeHash(InEntry.TypeID) ^ GetTypeHash(InEntry.StorageIndex);
    }
    friend bool operator==(const FPreAnimatedStateCachedValueHandle& A, const FPreAnimatedStateCachedValueHandle& B)
    {
        return A.TypeID == B.TypeID && A.StorageIndex == B.StorageIndex;
    }
};
 
 
struct FPreAnimatedStateEntry
{
    FPreAnimatedStorageGroupHandle GroupHandle;
    FPreAnimatedStateCachedValueHandle ValueHandle;
 
    bool IsValid() const
    {
        return ValueHandle.StorageIndex.IsValid();
    }
 
    explicit operator bool() const
    {
        return ValueHandle.StorageIndex.IsValid();
    }
 
    friend uint32 GetTypeHash(const FPreAnimatedStateEntry& InEntry)
    {
        return GetTypeHash(InEntry.GroupHandle) ^ GetTypeHash(InEntry.ValueHandle);
    }
    friend bool operator==(const FPreAnimatedStateEntry& A, const FPreAnimatedStateEntry& B)
    {
        return A.GroupHandle == B.GroupHandle && A.ValueHandle == B.ValueHandle;
    }
};
 
 
struct FPreAnimatedStateMetaData
{
    FPreAnimatedStateEntry Entry;
    FRootInstanceHandle RootInstanceHandle;
    bool bWantsRestoreState;
};
using FPreAnimatedStateMetaDataArray = TArray<FPreAnimatedStateMetaData, TInlineAllocator<1>>;
 
 
 
 
} // namespace MovieScene
} // namespace UE