CollisionProfile.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 "Engine/EngineTypes.h"
#include "Engine/DeveloperSettings.h"
 
#include "CollisionProfile.generated.h"
 
struct FBodyInstance;
struct FCollisionResponseParams;
struct FPropertyChangedEvent;
 
USTRUCT(BlueprintType)
struct FCollisionProfileName
{
    GENERATED_USTRUCT_BODY()
 
    FCollisionProfileName()
        : Name(NAME_None)
    {}
 
    FCollisionProfileName(const FName InName)
        : Name(InName)
    {}
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Collision)
    FName Name;
};
 
 
USTRUCT()
struct FCollisionResponseTemplate
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    FName Name;
 
    UPROPERTY()
    TEnumAsByte<ECollisionEnabled::Type> CollisionEnabled;
 
    // no property anymore
    TEnumAsByte<enum ECollisionChannel> ObjectType;
 
    UPROPERTY()
    bool    bCanModify;
 
    struct FCollisionResponseContainer ResponseToChannels;
 
    UPROPERTY()
    FName ObjectTypeName;
 
    UPROPERTY()
    TArray<FResponseChannel>    CustomResponses;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FString HelpMessage;
#endif
 
    ENGINE_API FCollisionResponseTemplate();
 
    ENGINE_API bool IsEqual(const TEnumAsByte<ECollisionEnabled::Type> InCollisionEnabled, 
        const TEnumAsByte<enum ECollisionChannel> InCollisionObjectType, 
        const struct FCollisionResponseContainer& InResponseToChannels);
 
    ENGINE_API void CreateCustomResponsesFromResponseContainers();
};
 
 
USTRUCT()
struct FCustomChannelSetup
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TEnumAsByte<enum ECollisionChannel> Channel;
 
    UPROPERTY()
    TEnumAsByte<enum ECollisionResponse> DefaultResponse;
 
    UPROPERTY()
    bool bTraceType;
    
    UPROPERTY()
    bool bStaticObject; 
 
    UPROPERTY()
    FName Name;
 
    FCustomChannelSetup()
        : Channel(ECC_WorldStatic)
        , DefaultResponse(ECR_Block)
        , bTraceType(false)
        , bStaticObject(false)
    { }
 
    bool operator==(const FCustomChannelSetup& Other) const
    {
        return (Channel == Other.Channel);
    }
};
 
 
USTRUCT()
struct FCustomProfile
{
    GENERATED_USTRUCT_BODY()
    
    
    UPROPERTY()
    FName Name;
 
    UPROPERTY()
    TArray<FResponseChannel>    CustomResponses;
};
 
 
UCLASS(config=Engine, defaultconfig, MinimalAPI, meta=(DisplayName="Collision"))
class UCollisionProfile : public UDeveloperSettings
{
    GENERATED_UCLASS_BODY()
 
private:
 
    UPROPERTY(globalconfig)
    TArray<FCollisionResponseTemplate>  Profiles;
 
    UPROPERTY(globalconfig)
    TArray<FCustomChannelSetup>         DefaultChannelResponses;
 
    UPROPERTY(globalconfig)
    TArray<FCustomProfile>              EditProfiles;
 
    UPROPERTY(globalconfig)
    TArray<FRedirector>                 ProfileRedirects;
 
    UPROPERTY(globalconfig)
    TArray<FRedirector>                 CollisionChannelRedirects;
 
public:
 
    static ENGINE_API const FName NoCollision_ProfileName;
    static ENGINE_API const FName BlockAll_ProfileName;
    static ENGINE_API const FName PhysicsActor_ProfileName;
    static ENGINE_API const FName BlockAllDynamic_ProfileName;
    static ENGINE_API const FName Pawn_ProfileName;
    static ENGINE_API const FName Vehicle_ProfileName;
    static ENGINE_API const FName DefaultProjectile_ProfileName;
 
    ENGINE_API static UCollisionProfile* Get();
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnLoadProfileConfig, UCollisionProfile*);
    FOnLoadProfileConfig OnLoadProfileConfig;
 
    virtual void PostReloadConfig(class FProperty* PropertyThatWasLoaded) override;
    ENGINE_API static void GetProfileNames(TArray<TSharedPtr<FName>>& OutNameList);
 
    ENGINE_API static bool GetChannelAndResponseParams(FName ProfileName, ECollisionChannel &CollisionChannel, FCollisionResponseParams &ResponseParams);
 
    bool ReadConfig(FName ProfileName, struct FBodyInstance& BodyInstance) const;
 
    ENGINE_API bool GetProfileTemplate(FName ProfileName, struct FCollisionResponseTemplate& ProfileData) const;
 
    ENGINE_API const FName* LookForProfileRedirect(FName ProfileName) const;
 
    int32 GetNumOfProfiles() const { return Profiles.Num(); }
 
    ENGINE_API const FCollisionResponseTemplate* GetProfileByIndex(int32 Index) const;
 
    ENGINE_API void LoadProfileConfig(bool bForceInit=false);
 
    int32 ReturnContainerIndexFromChannelName(FName& InOutDisplayName)  const;
    ENGINE_API FName ReturnChannelNameFromContainerIndex(int32 ContainerIndex)  const;
 
    ENGINE_API ECollisionChannel ConvertToCollisionChannel(bool TraceType, int32 Index) const;
 
    ENGINE_API EObjectTypeQuery ConvertToObjectType(ECollisionChannel CollisionChannel) const;
 
    ENGINE_API ETraceTypeQuery ConvertToTraceType(ECollisionChannel CollisionChannel) const;
 
    /* custom collision profile name that you can modify what you'd like */
    ENGINE_API static FName CustomCollisionProfileName;
 
#if WITH_EDITOR
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif //WITH_EDITOR
private:
 
    TMap<FName, FName> ProfileRedirectsMap;
 
    TMap<FName, FName> CollisionChannelRedirectsMap;
 
    TArray<FName> ChannelDisplayNames;
 
    TArray<ECollisionChannel> ObjectTypeMapping;
    TArray<ECollisionChannel> TraceTypeMapping;
 
    bool FindProfileData(const TArray<FCollisionResponseTemplate>& ProfileList, FName ProfileName, struct FCollisionResponseTemplate& ProfileData) const;
 
    bool CheckRedirect(FName ProfileName, FBodyInstance& BodyInstance, struct FCollisionResponseTemplate& Template) const;
 
    void FillProfileData(TArray<FCollisionResponseTemplate>& ProfileList, const UEnum* CollisionChannelEnum, TArray<FCustomProfile>& EditProfileList);
 
    int32 LoadCustomResponses(FCollisionResponseTemplate& Template, const UEnum* CollisionChannelEnum, TArray<FResponseChannel>& CustomResponses) const;
    ENGINE_API void SaveCustomResponses(FCollisionResponseTemplate& Template) const;
 
    ENGINE_API void AddChannelRedirect(FName OldName, FName NewName);
    ENGINE_API void AddProfileRedirect(FName OldName, FName NewName);
 
    friend class FCollisionProfileDetails;
    friend struct FCollisionProfilePrivateAccessor;
};
 
struct FCollisionProfilePrivateAccessor
{
    static ENGINE_API bool AddProfileTemplate(FCollisionResponseTemplate& NewProfileData);
};