ParticleModuleLocationBoneSocket.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "ParticleHelper.h"
#include "Particles/Location/ParticleModuleLocationBase.h"
#include "ParticleModuleLocationBoneSocket.generated.h"
 
class UParticleModuleTypeDataBase;
class UParticleSystemComponent;
class USkeletalMeshComponent;
class USkeletalMeshSocket;
struct FModuleLocationBoneSocketInstancePayload;
struct FParticleEmitterInstance;
 
UENUM()
enum ELocationBoneSocketSource : int
{
    BONESOCKETSOURCE_Bones,
    BONESOCKETSOURCE_Sockets,
    BONESOCKETSOURCE_MAX,
};
 
UENUM()
enum ELocationBoneSocketSelectionMethod : int
{
    BONESOCKETSEL_Sequential,
    BONESOCKETSEL_Random,
    BONESOCKETSEL_MAX,
};
 
USTRUCT()
struct FLocationBoneSocketInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=LocationBoneSocketInfo)
    FName BoneSocketName;
 
    UPROPERTY(EditAnywhere, Category=LocationBoneSocketInfo)
    FVector Offset;
 
 
    FLocationBoneSocketInfo()
        : Offset(ForceInit)
    {
    }
 
};
 
enum class EBoneSocketSourceIndexMode : uint8
{
    SourceLocations,//Module has source locations so SourceIndex is an index into these.
    PreSelectedIndices,//Module has no source locations but requires tracking of bone velocities so SourceIndex is an index into an array of preselected indices. These indices are Direct into the bone/sockets of the source mesh.
    Direct,//Module has no source locations and no bone tracking requirement so can simply access the mesh via direct indices to the bones/sockets.
};
 
UCLASS(editinlinenew, hidecategories=Object, meta=(DisplayName = "Bone/Socket Location"), MinimalAPI)
class UParticleModuleLocationBoneSocket : public UParticleModuleLocationBase
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=BoneSocket)
    TEnumAsByte<enum ELocationBoneSocketSource> SourceType;
 
    UPROPERTY(EditAnywhere, Category=BoneSocket)
    FVector UniversalOffset;
 
    UPROPERTY(EditAnywhere, Category=BoneSocket)
    TArray<struct FLocationBoneSocketInfo> SourceLocations;
 
    UPROPERTY(EditAnywhere, Category=BoneSocket)
    TEnumAsByte<enum ELocationBoneSocketSelectionMethod> SelectionMethod;
 
    UPROPERTY(EditAnywhere, Category=BoneSocket)
    uint32 bUpdatePositionEachFrame:1;
 
    UPROPERTY()
    uint32 bOrientMeshEmitters:1;
 
    UPROPERTY(EditAnywhere, Category=BoneSocket)
    uint32 bInheritBoneVelocity:1;
 
    UPROPERTY(EditAnywhere, Category = BoneSocket)
    float InheritVelocityScale;
 
    UPROPERTY(EditAnywhere, Category=BoneSocket)
    FName SkelMeshActorParamName;
    
    UPROPERTY(EditAnywhere, Category = BoneSocket, meta = (UIMin = "1"))
    int32 NumPreSelectedIndices;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category=BoneSocket)
    TObjectPtr<class USkeletalMesh> EditorSkelMesh;
 
#endif // WITH_EDITORONLY_DATA
 
    EBoneSocketSourceIndexMode SourceIndexMode;
 
    //~ Begin UParticleModule Interface
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void Spawn(const FSpawnContext& Context) override;
    ENGINE_API virtual void Update(const FUpdateContext& Context) override;
    ENGINE_API virtual void FinalUpdate(const FUpdateContext& Context) override;
    ENGINE_API virtual uint32   RequiredBytes(UParticleModuleTypeDataBase* TypeData) override;
    ENGINE_API virtual uint32   RequiredBytesPerInstance() override;
    ENGINE_API virtual uint32   PrepPerInstanceBlock(FParticleEmitterInstance* Owner, void* InstData) override;
    virtual bool    TouchesMeshRotation() const override { return true; }
    ENGINE_API virtual void AutoPopulateInstanceProperties(UParticleSystemComponent* PSysComp) override;
    virtual bool CanTickInAnyThread() override
    {
        return true;
    }
#if WITH_EDITOR
    ENGINE_API virtual int32 GetNumberOfCustomMenuOptions() const override;
    ENGINE_API virtual bool GetCustomMenuEntryDisplayString(int32 InEntryIndex, FString& OutDisplayString) const override;
    ENGINE_API virtual bool PerformCustomMenuEntry(int32 InEntryIndex) override; 
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)override;
#endif
    //~ End UParticleModule Interface
 
    ENGINE_API void GetSkeletalMeshComponentSource(const FContext& Context, FModuleLocationBoneSocketInstancePayload* InstancePayload);
 
    ENGINE_API bool GetParticleLocation(FModuleLocationBoneSocketInstancePayload* InstancePayload, FParticleEmitterInstance* Owner, USkeletalMeshComponent* InSkelMeshComponent, int32 InBoneSocketIndex, FVector& OutPosition, FQuat* OutRotation);
 
    ENGINE_API int32 GetMaxSourceIndex(FModuleLocationBoneSocketInstancePayload* Payload, USkeletalMeshComponent* SourceComponent)const;
    ENGINE_API bool GetSocketInfoForSourceIndex(FModuleLocationBoneSocketInstancePayload* InstancePayload, USkeletalMeshComponent* SourceComponent, int32 SourceIndex, USkeletalMeshSocket*& OutSocket, FVector& OutOffset)const;
    ENGINE_API bool GetBoneInfoForSourceIndex(FModuleLocationBoneSocketInstancePayload* InstancePayload, USkeletalMeshComponent* SourceComponent, int32 SourceIndex, FMatrix& OutBoneMatrix, FVector& OutOffset)const;
    
    ENGINE_API int32 SelectNextSpawnIndex(FModuleLocationBoneSocketInstancePayload* InstancePayload, USkeletalMeshComponent* SourceComponent, FRandomStream& InRandomStream);
    ENGINE_API void RegeneratePreSelectedIndices(FModuleLocationBoneSocketInstancePayload* InstancePayload, USkeletalMeshComponent* SourceComponent, FRandomStream& InRandomStream);
 
    ENGINE_API void UpdatePrevBoneLocationsAndVelocities(FModuleLocationBoneSocketInstancePayload* InstancePayload, USkeletalMeshComponent* SourceComponent, float DeltaTime);
 
    //If we're updating our position each frame, there's no point in inheriting bone velocity
    inline bool InheritingBoneVelocity()const { return bInheritBoneVelocity && !bUpdatePositionEachFrame; }
 
    ENGINE_API void SetSourceIndexMode();
 
    static ENGINE_API void ValidateLODLevels(UParticleEmitter* Emitter, int32 iModule);
};
 
struct FModuleLocationBoneSocketInstancePayload
{
    TWeakObjectPtr<USkeletalMeshComponent> SourceComponent;
    TWeakObjectPtr<AActor> CachedActor;
    int32 LastSelectedIndex;
    TPreallocatedArrayProxy<FVector3f> PrevFrameBoneSocketPositions;
    TPreallocatedArrayProxy<FVector3f> BoneSocketVelocities;
    TPreallocatedArrayProxy<int32> PreSelectedBoneSocketIndices;
 
    void InitArrayProxies(int32 FixedArraySize)
    {
        // Calculate offsets into instance data buffer for the arrays and initialize the buffer proxies. The allocation 
        // size for these arrays is calculated in RequiredBytesPerInstance.
        const uint32 StructSize = sizeof(FModuleLocationBoneSocketInstancePayload);
        PrevFrameBoneSocketPositions = TPreallocatedArrayProxy<FVector3f>((uint8*)this + StructSize, FixedArraySize);
 
        uint32 StructOffset = StructSize + (FixedArraySize*sizeof(FVector3f));
        BoneSocketVelocities = TPreallocatedArrayProxy<FVector3f>((uint8*)this + StructOffset, FixedArraySize);
        StructOffset += (FixedArraySize*sizeof(FVector3f));
 
        PreSelectedBoneSocketIndices = TPreallocatedArrayProxy<int32>((uint8*)this + StructOffset, FixedArraySize);
        StructOffset += (FixedArraySize*sizeof(int32));
    }
};