UALSAnimNotifyFootstep Class Reference

#include <ALSAnimNotifyFootstep.h>

Inheritance diagram for UALSAnimNotifyFootstep:

Public Attributes
TObjectPtr< UDataTable >	HitDataTable
FName	FootSocketName = NAME_Foot_R
TEnumAsByte< ETraceTypeQuery >	TraceChannel
TEnumAsByte< EDrawDebugTrace::Type >	DrawDebugType
float	TraceLength = 50.0f
bool	bSpawnDecal = false
bool	bMirrorDecalX = false
bool	bMirrorDecalY = false
bool	bMirrorDecalZ = false
bool	bSpawnSound = true
FName	SoundParameterName = NAME_FootstepType
EALSFootstepType	FootstepType = EALSFootstepType::Step
bool	bOverrideMaskCurve = false
float	VolumeMultiplier = 1.0f
float	PitchMultiplier = 1.0f
bool	bSpawnNiagara = false

Static Public Attributes
static FName	NAME_Foot_R
static FName	NAME_FootstepType

Private Member Functions
virtual void	Notify (USkeletalMeshComponent *MeshComp, UAnimSequenceBase *Animation, const FAnimNotifyEventReference &EventReference) override
virtual FString	GetNotifyName_Implementation () const override

Detailed Description

Character footstep anim notify

Member Function Documentation

GetNotifyName_Implementation()

FString UALSAnimNotifyFootstep::GetNotifyName_Implementation ( ) const

overrideprivatevirtual

{
    FString Name(TEXT("Footstep Type: "));
    Name.Append(GetEnumerationToString(FootstepType));
    return Name;
}

Notify()

void UALSAnimNotifyFootstep::Notify ( USkeletalMeshComponent * MeshComp, UAnimSequenceBase * Animation, const FAnimNotifyEventReference & EventReference )

overrideprivatevirtual

{
    Super::Notify(MeshComp, Animation, EventReference);
 
    if (!MeshComp)
    {
        return;
    }
 
    AActor* MeshOwner = MeshComp->GetOwner();
    if (!MeshOwner)
    {
        return;
    }
 
    if (HitDataTable)
    {
        UWorld* World = MeshComp->GetWorld();
        check(World);
 
        const FVector FootLocation = MeshComp->GetSocketLocation(FootSocketName);
        const FRotator FootRotation = MeshComp->GetSocketRotation(FootSocketName);
        const FVector TraceEnd = FootLocation - MeshOwner->GetActorUpVector() * TraceLength;
 
        FHitResult Hit;
 
        if (UKismetSystemLibrary::LineTraceSingle(MeshOwner /*used by bIgnoreSelf*/, FootLocation, TraceEnd, TraceChannel, true /*bTraceComplex*/, MeshOwner->Children,
                                                  DrawDebugType, Hit, true /*bIgnoreSelf*/))
        {
            if (!Hit.PhysMaterial.Get())
            {
                return;
            }
 
            const EPhysicalSurface SurfaceType = Hit.PhysMaterial.Get()->SurfaceType;
 
            check(IsInGameThread());
            checkNoRecursion();
            static TArray<FALSHitFX*> HitFXRows;
            HitFXRows.Reset();
 
            HitDataTable->GetAllRows<FALSHitFX>(FString(), HitFXRows);
 
            FALSHitFX* HitFX = nullptr;
            if (auto FoundResult = HitFXRows.FindByPredicate([&](const FALSHitFX* Value)
            {
                return SurfaceType == Value->SurfaceType;
            }))
            {
                HitFX = *FoundResult;
            }
            else if (auto DefaultResult = HitFXRows.FindByPredicate([&](const FALSHitFX* Value)
            {
                return EPhysicalSurface::SurfaceType_Default == Value->SurfaceType;
            }))
            {
                HitFX = *DefaultResult;
            }
            else
            {
                return;
            }
 
            if (bSpawnSound && HitFX->Sound.LoadSynchronous())
            {
                UAudioComponent* SpawnedSound = nullptr;
 
                const float MaskCurveValue = MeshComp->GetAnimInstance()->GetCurveValue(
                    NAME_Mask_FootstepSound);
                const float FinalVolMult = bOverrideMaskCurve
                                               ? VolumeMultiplier
                                               : VolumeMultiplier * (1.0f - MaskCurveValue);
 
                switch (HitFX->SoundSpawnType)
                {
                case EALSSpawnType::Location:
                    SpawnedSound = UGameplayStatics::SpawnSoundAtLocation(
                        World, HitFX->Sound.Get(), Hit.Location + HitFX->SoundLocationOffset,
                        HitFX->SoundRotationOffset, FinalVolMult, PitchMultiplier);
                    break;
 
                case EALSSpawnType::Attached:
                    SpawnedSound = UGameplayStatics::SpawnSoundAttached(HitFX->Sound.Get(), MeshComp, FootSocketName,
                                                                        HitFX->SoundLocationOffset,
                                                                        HitFX->SoundRotationOffset,
                                                                        HitFX->SoundAttachmentType, true, FinalVolMult,
                                                                        PitchMultiplier);
 
                    break;
                }
                if (SpawnedSound)
                {
                    SpawnedSound->SetIntParameter(SoundParameterName, static_cast<int32>(FootstepType));
                }
            }
 
            if (bSpawnNiagara && HitFX->NiagaraSystem.LoadSynchronous())
            {
                UNiagaraComponent* SpawnedParticle = nullptr;
                const FVector Location = Hit.Location + MeshOwner->GetTransform().TransformVector(
                    HitFX->DecalLocationOffset);
 
                switch (HitFX->NiagaraSpawnType)
                {
                case EALSSpawnType::Location:
                    SpawnedParticle = UNiagaraFunctionLibrary::SpawnSystemAtLocation(
                        World, HitFX->NiagaraSystem.Get(), Location, FootRotation + HitFX->NiagaraRotationOffset);
                    break;
 
                case EALSSpawnType::Attached:
                    SpawnedParticle = UNiagaraFunctionLibrary::SpawnSystemAttached(
                        HitFX->NiagaraSystem.Get(), MeshComp, FootSocketName, HitFX->NiagaraLocationOffset,
                        HitFX->NiagaraRotationOffset, HitFX->NiagaraAttachmentType, true);
                    break;
                }
            }
 
            if (bSpawnDecal && HitFX->DecalMaterial.LoadSynchronous())
            {
                const FVector Location = Hit.Location + MeshOwner->GetTransform().TransformVector(
                    HitFX->DecalLocationOffset);
 
                const FVector DecalSize = FVector(bMirrorDecalX ? -HitFX->DecalSize.X : HitFX->DecalSize.X,
                                                  bMirrorDecalY ? -HitFX->DecalSize.Y : HitFX->DecalSize.Y,
                                                  bMirrorDecalZ ? -HitFX->DecalSize.Z : HitFX->DecalSize.Z);
 
                UDecalComponent* SpawnedDecal = nullptr;
                switch (HitFX->DecalSpawnType)
                {
                case EALSSpawnType::Location:
                    SpawnedDecal = UGameplayStatics::SpawnDecalAtLocation(
                        World, HitFX->DecalMaterial.Get(), DecalSize, Location,
                        FootRotation + HitFX->DecalRotationOffset, HitFX->DecalLifeSpan);
                    break;
 
                case EALSSpawnType::Attached:
                    SpawnedDecal = UGameplayStatics::SpawnDecalAttached(HitFX->DecalMaterial.Get(), DecalSize,
                                                                        Hit.Component.Get(), NAME_None, Location,
                                                                        FootRotation + HitFX->DecalRotationOffset,
                                                                        HitFX->DecalAttachmentType,
                                                                        HitFX->DecalLifeSpan);
                    break;
                }
            }
        }
    }
}

Member Data Documentation

bMirrorDecalX

bool UALSAnimNotifyFootstep::bMirrorDecalX = false

bMirrorDecalY

bool UALSAnimNotifyFootstep::bMirrorDecalY = false

bMirrorDecalZ

bool UALSAnimNotifyFootstep::bMirrorDecalZ = false

bOverrideMaskCurve

bool UALSAnimNotifyFootstep::bOverrideMaskCurve = false

bSpawnDecal

bool UALSAnimNotifyFootstep::bSpawnDecal = false

bSpawnNiagara

bool UALSAnimNotifyFootstep::bSpawnNiagara = false

bSpawnSound

bool UALSAnimNotifyFootstep::bSpawnSound = true

DrawDebugType

TEnumAsByte<EDrawDebugTrace::Type> UALSAnimNotifyFootstep::DrawDebugType

FootSocketName

FName UALSAnimNotifyFootstep::FootSocketName = NAME_Foot_R

FootstepType

EALSFootstepType UALSAnimNotifyFootstep::FootstepType = EALSFootstepType::Step

HitDataTable

TObjectPtr<UDataTable> UALSAnimNotifyFootstep::HitDataTable

NAME_Foot_R

FName UALSAnimNotifyFootstep::NAME_Foot_R

static

NAME_FootstepType

FName UALSAnimNotifyFootstep::NAME_FootstepType

static

PitchMultiplier

float UALSAnimNotifyFootstep::PitchMultiplier = 1.0f

SoundParameterName

FName UALSAnimNotifyFootstep::SoundParameterName = NAME_FootstepType

TraceChannel

TEnumAsByte<ETraceTypeQuery> UALSAnimNotifyFootstep::TraceChannel

TraceLength

float UALSAnimNotifyFootstep::TraceLength = 50.0f

VolumeMultiplier

float UALSAnimNotifyFootstep::VolumeMultiplier = 1.0f

---

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

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/ALS-Community-main/Source/ALSV4_CPP/Public/Character/Animation/Notify/ALSAnimNotifyFootstep.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/ALS-Community-main/Source/ALSV4_CPP/Private/Character/Animation/Notify/ALSAnimNotifyFootstep.cpp