AnimNodeData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
 
#include "AnimNodeData.generated.h"
 
class IAnimClassInterface;
struct FAnimNode_Base;
struct FAnimNodeData;
 
// Flag used to specify whether an anim node data entry is held on an instance or the class
#define ANIM_NODE_DATA_INVALID_ENTRY 0xffffffff
#define ANIM_NODE_DATA_INSTANCE_DATA_FLAG 0x80000000
#define ANIM_NODE_DATA_INSTANCE_DATA_MASK ~ANIM_NODE_DATA_INSTANCE_DATA_FLAG
 
namespace UE { namespace Anim {
 
// Identifier used to access folded node data.
struct FNodeDataId
{
    friend struct ::FAnimNodeData;
    friend struct ::FAnimNode_Base;
 
    // Check if this ID is valid
    bool IsValid() const
    {
        return Index != INDEX_NONE;
    }
 
#if WITH_EDITORONLY_DATA    
    // Get the node struct associated with this ID
    const UScriptStruct* GetStruct() const
    {
        return Struct;
    }
    
    // Get the node property associated with this ID
    const FProperty* GetProperty() const
    {
        return Property;
    }
#endif
 
    FNodeDataId() = default;
    
    // Construct from a property name and struct
    ENGINE_API FNodeDataId(FName InPropertyName, const FAnimNode_Base* InNode, const UScriptStruct* InNodeStruct);
    
private:
    // Name-based ID
    FName Id = NAME_None;
 
    // Index into the folded data table
    int32 Index = INDEX_NONE;
 
#if WITH_EDITORONLY_DATA
    // Struct of the node
    const UScriptStruct* Struct = nullptr;
 
    // Property of the data on the node
    const FProperty* Property = nullptr;
#endif
};
 
} } // namespace UE::Anim
 
// The flags field of FAnimNodeData
// Primarily this is used to prevent the extra work asscicated with recovering folded properties for anim node functions
UENUM()
enum class EAnimNodeDataFlags : uint32
{
    None                        = 0x00000000,
    
    // This node binds its initial update function
    HasInitialUpdateFunction    = 0x00000001,
 
    // This node binds its become relevant function
    HasBecomeRelevantFunction   = 0x00000002,
 
    // This node binds its update function
    HasUpdateFunction           = 0x00000004,
 
    AllFunctions = HasInitialUpdateFunction | HasBecomeRelevantFunction | HasUpdateFunction,
};
 
ENUM_CLASS_FLAGS(EAnimNodeDataFlags);
 
// Any constant/folded class data an anim node can be accessed via this struct
USTRUCT(BlueprintInternalUseOnly)
struct FAnimNodeData
{
    GENERATED_BODY()
 
public:
    ENGINE_API const void* GetData(UE::Anim::FNodeDataId InId, const FAnimNode_Base* InNode, const UObject* InCurrentObject = nullptr) const;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void* GetMutableData(UE::Anim::FNodeDataId InId, FAnimNode_Base* InNode, UObject* InCurrentObject = nullptr) const;
#endif
 
    ENGINE_API void* GetInstanceData(UE::Anim::FNodeDataId InId, FAnimNode_Base* InNode, UObject* InCurrentObject = nullptr) const;
    
    const IAnimClassInterface& GetAnimClassInterface() const { check(AnimClassInterface); return *AnimClassInterface; }
 
    int32 GetNodeIndex() const { return NodeIndex; }
 
    bool HasNodeAnyFlags(EAnimNodeDataFlags InFlags) const { return EnumHasAnyFlags(static_cast<EAnimNodeDataFlags>(Flags), InFlags); }
    
private:
    friend class FAnimBlueprintCompilerContext;
    friend struct UE::Anim::FNodeDataId;
 
    void SetNodeFlags(EAnimNodeDataFlags InFlags) { return EnumAddFlags(*reinterpret_cast<EAnimNodeDataFlags*>(&Flags), InFlags); }
    
    UPROPERTY()
    TScriptInterface<IAnimClassInterface> AnimClassInterface = nullptr;
 
    UPROPERTY()
    TArray<uint32> Entries;
    
    UPROPERTY()
    int32 NodeIndex = INDEX_NONE;
 
    UPROPERTY()
    uint32 Flags = static_cast<uint32>(EAnimNodeDataFlags::None);
};
 
USTRUCT()
struct FAnimNodeStructData
{
    GENERATED_BODY()
    
    FAnimNodeStructData() = default;
 
    ENGINE_API FAnimNodeStructData(const UScriptStruct* InNodeType);
 
    ENGINE_API int32 GetPropertyIndex(FName InPropertyName) const;
 
    ENGINE_API int32 GetNumProperties() const;
 
#if WITH_EDITORONLY_DATA
    // Verifies the layout of another struct data against this one
    // Note: uses name + index, so not robust to type/size changes. This is OK however as tagged property serializaton
    // will deal with those and names/indices are all we need to be consistent at this level (as we inderect by name/index)
    ENGINE_API bool DoesLayoutMatch(const FAnimNodeStructData& InOther) const;
#endif
    
private:
    UPROPERTY()
    TMap<FName, int32> NameToIndexMap;
 
    UPROPERTY()
    int32 NumProperties = 0;
};