FAnimNode_RecoilAnimationNode Struct Reference

#include <AnimNode_RecoilAnimationNode.h>

Inheritance diagram for FAnimNode_RecoilAnimationNode:

Public Member Functions
virtual void	EvaluateSkeletalControl_AnyThread (FComponentSpacePoseContext &Output, TArray< FBoneTransform > &OutBoneTransforms) override
virtual bool	IsValidToEvaluate (const USkeleton *Skeleton, const FBoneContainer &RequiredBones) override
virtual bool	HasPreUpdate () const override
virtual void	PreUpdate (const UAnimInstance *InAnimInstance) override

Public Attributes
FBoneReference	BoneToModify
FVector	TranslationScale = FVector::OneVector
FVector	RotationScale = FVector::OneVector
TEnumAsByte< ERecoilAxesOrder >	AxesOrder = ERecoilAxesOrder::XYZ
bool	bUseAutoUpdate = true
FVector	Translation = FVector::ZeroVector
FRotator	Rotation = FRotator::ZeroRotator
TEnumAsByte< enum EBoneControlSpace >	TranslationSpace = BCS_BoneSpace
TEnumAsByte< enum EBoneControlSpace >	RotationSpace = BCS_BoneSpace

Private Member Functions
virtual void	InitializeBoneReferences (const FBoneContainer &RequiredBones) override
FTransform	ComputeRecoilTransform ()

Private Attributes
bool	bIsInitialized = false
TWeakObjectPtr< URecoilAnimationComponent >	RecoilComponent
FTransform	RecoilTransform

Member Function Documentation

ComputeRecoilTransform()

FTransform FAnimNode_RecoilAnimationNode::ComputeRecoilTransform ( )

private

{
    FTransform FinalTransform = bUseAutoUpdate
                                    ? RecoilTransform
                                    : FTransform(Rotation.Quaternion(), Translation);
 
    switch (AxesOrder)
    {
    case ERecoilAxesOrder::XZY:
        FinalTransform.SetLocation(FVector(FinalTransform.GetLocation().X, FinalTransform.GetLocation().Z,
                                           FinalTransform.GetLocation().Y));
        FinalTransform.SetRotation(FRotator(FinalTransform.Rotator().Pitch, FinalTransform.Rotator().Roll,
                                            FinalTransform.Rotator().Yaw).Quaternion());
        break;
    case ERecoilAxesOrder::YXZ:
        FinalTransform.SetLocation(FVector(FinalTransform.GetLocation().Y, FinalTransform.GetLocation().X,
                                           FinalTransform.GetLocation().Z));
        FinalTransform.SetRotation(FRotator(FinalTransform.Rotator().Roll, FinalTransform.Rotator().Yaw,
                                            FinalTransform.Rotator().Pitch).Quaternion());
        break;
    case ERecoilAxesOrder::YZX:
        FinalTransform.SetLocation(FVector(FinalTransform.GetLocation().Y, FinalTransform.GetLocation().Z,
                                           FinalTransform.GetLocation().X));
        FinalTransform.SetRotation(FRotator(FinalTransform.Rotator().Roll, FinalTransform.Rotator().Pitch,
                                            FinalTransform.Rotator().Yaw).Quaternion());
        break;
    case ERecoilAxesOrder::ZXY:
        FinalTransform.SetLocation(FVector(FinalTransform.GetLocation().Z, FinalTransform.GetLocation().X,
                                           FinalTransform.GetLocation().Y));
        FinalTransform.SetRotation(FRotator(FinalTransform.Rotator().Yaw, FinalTransform.Rotator().Pitch,
                                            FinalTransform.Rotator().Roll).Quaternion());
        break;
    case ERecoilAxesOrder::ZYX:
        FinalTransform.SetLocation(FVector(FinalTransform.GetLocation().Z, FinalTransform.GetLocation().Y,
                                           FinalTransform.GetLocation().X));
        FinalTransform.SetRotation(FRotator(FinalTransform.Rotator().Yaw, FinalTransform.Rotator().Roll,
                                            FinalTransform.Rotator().Pitch).Quaternion());
        break;
    default:
        break;
    }
 
    return FinalTransform;
}

EvaluateSkeletalControl_AnyThread()

void FAnimNode_RecoilAnimationNode::EvaluateSkeletalControl_AnyThread ( FComponentSpacePoseContext & Output, TArray< FBoneTransform > & OutBoneTransforms )

overridevirtual

{
    DECLARE_SCOPE_HIERARCHICAL_COUNTER_ANIMNODE(EvaluateSkeletalControl_AnyThread)
    check(OutBoneTransforms.Num() == 0);
 
    const FBoneContainer& BoneContainer = Output.Pose.GetPose().GetBoneContainer();
 
    FCompactPoseBoneIndex CompactPoseBoneToModify = BoneToModify.GetCompactPoseIndex(BoneContainer);
    FTransform NewBoneTM = Output.Pose.GetComponentSpaceTransform(CompactPoseBoneToModify);
    FTransform ComponentTransform = Output.AnimInstanceProxy->GetComponentTransform();
 
    FAnimationRuntime::ConvertCSTransformToBoneSpace(ComponentTransform, Output.Pose, NewBoneTM,
                                                     CompactPoseBoneToModify, RotationSpace);
 
    FTransform FinalTransform = ComputeRecoilTransform();
 
    FVector FinalPosition = FinalTransform.GetTranslation();
    FRotator FinalRotation = FinalTransform.Rotator();
 
    FinalPosition.X *= TranslationScale.X;
    FinalPosition.Y *= TranslationScale.Y;
    FinalPosition.Z *= TranslationScale.Z;
 
    FinalRotation.Pitch *= RotationScale.Y;
    FinalRotation.Yaw *= RotationScale.Z;
    FinalRotation.Roll *= RotationScale.X;
 
    FinalTransform.SetTranslation(FinalPosition);
    FinalTransform.SetRotation(FinalRotation.Quaternion());
 
    const FQuat BoneQuat = FinalTransform.GetRotation();
 
    NewBoneTM.SetRotation(BoneQuat * NewBoneTM.GetRotation());
 
    FAnimationRuntime::ConvertBoneSpaceTransformToCS(ComponentTransform, Output.Pose, NewBoneTM,
                                                     CompactPoseBoneToModify, RotationSpace);
 
    FAnimationRuntime::ConvertCSTransformToBoneSpace(ComponentTransform, Output.Pose, NewBoneTM,
                                                     CompactPoseBoneToModify, TranslationSpace);
 
    NewBoneTM.AddToTranslation(FinalTransform.GetTranslation());
 
 
    FAnimationRuntime::ConvertBoneSpaceTransformToCS(ComponentTransform, Output.Pose, NewBoneTM,
                                                     CompactPoseBoneToModify, TranslationSpace);
 
 
    OutBoneTransforms.Add(FBoneTransform(BoneToModify.GetCompactPoseIndex(BoneContainer), NewBoneTM));
 
    TRACE_ANIM_NODE_VALUE(Output, TEXT("Target"), BoneToModify.BoneName);
}

HasPreUpdate()

virtual bool FAnimNode_RecoilAnimationNode::HasPreUpdate ( ) const

inlineoverridevirtual

{ return bUseAutoUpdate; }

InitializeBoneReferences()

void FAnimNode_RecoilAnimationNode::InitializeBoneReferences ( const FBoneContainer & RequiredBones )

overrideprivatevirtual

{
    DECLARE_SCOPE_HIERARCHICAL_COUNTER_ANIMNODE(InitializeBoneReferences)
    BoneToModify.Initialize(RequiredBones);
}

IsValidToEvaluate()

bool FAnimNode_RecoilAnimationNode::IsValidToEvaluate ( const USkeleton * Skeleton, const FBoneContainer & RequiredBones )

overridevirtual

{
    return (BoneToModify.IsValidToEvaluate(RequiredBones));
}

PreUpdate()

void FAnimNode_RecoilAnimationNode::PreUpdate ( const UAnimInstance * InAnimInstance )

overridevirtual

{
    if (!bIsInitialized)
    {
        if (auto Owner = InAnimInstance->GetOwningActor())
        {
            if (!Owner->HasActorBegunPlay())
            {
                return;
            }
 
            if (auto Component = Owner->FindComponentByClass<URecoilAnimationComponent>())
            {
                RecoilComponent = Component;
            }
        }
 
        bIsInitialized = true;
    }
    if (RecoilComponent.IsValid())
    {
        RecoilTransform = RecoilComponent->GetOutput();
    }
}

Member Data Documentation

AxesOrder

TEnumAsByte<ERecoilAxesOrder> FAnimNode_RecoilAnimationNode::AxesOrder = ERecoilAxesOrder::XYZ

bIsInitialized

bool FAnimNode_RecoilAnimationNode::bIsInitialized = false

private

BoneToModify

FBoneReference FAnimNode_RecoilAnimationNode::BoneToModify

bUseAutoUpdate

bool FAnimNode_RecoilAnimationNode::bUseAutoUpdate = true

RecoilComponent

TWeakObjectPtr<URecoilAnimationComponent> FAnimNode_RecoilAnimationNode::RecoilComponent

private

RecoilTransform

FTransform FAnimNode_RecoilAnimationNode::RecoilTransform

private

Rotation

FRotator FAnimNode_RecoilAnimationNode::Rotation = FRotator::ZeroRotator

RotationScale

FVector FAnimNode_RecoilAnimationNode::RotationScale = FVector::OneVector

RotationSpace

TEnumAsByte<enum EBoneControlSpace> FAnimNode_RecoilAnimationNode::RotationSpace = BCS_BoneSpace

Translation

FVector FAnimNode_RecoilAnimationNode::Translation = FVector::ZeroVector

TranslationScale

FVector FAnimNode_RecoilAnimationNode::TranslationScale = FVector::OneVector

TranslationSpace

TEnumAsByte<enum EBoneControlSpace> FAnimNode_RecoilAnimationNode::TranslationSpace = BCS_BoneSpace

---

The documentation for this struct was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/RecoilAnimation/Source/RecoilAnimation/Public/AnimNode_RecoilAnimationNode.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/RecoilAnimation/Source/RecoilAnimation/Private/AnimNode_RecoilAnimationNode.cpp