UBaseHelpersBPLib Class Reference

#include <BaseHelpersBPLib.h>

Inheritance diagram for UBaseHelpersBPLib:

Static Public Member Functions
static UWorld *	FindPlayInEditorAuthorityWorld ()
static APlayerController *	FindPlayInEditorAuthorityPlayerController (const APlayerController *ClientController)
static void	PrintToLog (const UObject *WorldContextObject, const FString &Message, const bool bWarning=false, const bool bError=false)
static void	PrintToLogWithCategory (const UObject *WorldContextObject, const FLogCategoryBase &Category, const FString &Message, const bool bWarning=false, const bool bError=false)
static FCharacterBaseSkills	RandomCharacterSkills (const int32 Min, const int32 Max)
static int32	GetPlayerTeamID (AController *Controller)
static int32	GetPlayerTeamID (APlayerState *PlayerState)
static int32	GetPlayerTeamIDFromController (AController *Controller)
static int32	GetPlayerTeamIDFromState (APlayerState *PlayerState)
static UClass *	GetDefaultBPClass (const FString &Location)
static TSubclassOf< AActor >	GetDefaultActorBPClass (const FString &Location)
static TSubclassOf< UUserWidget >	GetDefaultWidgetBPClass (const FString &Location)
static UDataTable *	GetDefaultDataTable (const FString &Location)
static void	PrintVirtualBoneInfo (USkeletalMeshComponent *SkeletalMeshComponent)
static void	ToggleWidgetVisibility (UUserWidget *Widget, const bool bForceSetVisible=false, const bool bForceSetCollapsed=false)
static void	ToggleInputMode (APlayerController *InController, const bool bForceGameOnly=false, const bool bForceUI=false, class UUserWidget *WidgetToFocus=nullptr)
static ESoundSource	SoundSourceFromName (const FName &SoundName)
static FName	SoundNameFromSource (const ESoundSource SoundSource)
static FString	GetGameplayTagName (const FGameplayTag &GameplayTag)
static FString	DescribeColorHelper (const FColor &Color)
static TArray< FGameplayTag >	GetAllTagsOfCategory (const FName &Category)
static FString	GetEnumValue (const FString &BaseString)
static bool	GetInteraction (FInteractionType &InteractionType, const FInteractionData &InteractionData, const int32 Value)
static bool	GetInteractionFromType (FInteractionType &InteractionType, const FInteractionData &InteractionData, const EInteractionType Interaction)
static bool	LineTraceByChannel (const UObject *WorldContextObject, FHitResult &Hit, const FVector &Start, const FVector &End, const ETraceTypeQuery TraceChannel, const TArray< AActor * > &ActorsToIgnore, const bool bIgnoreSelf, const bool bReturnPhysicalMaterial=false, const bool bTraceComplex=false, const bool bDebug=false, const FLinearColor TraceColor=FLinearColor::Red, const float DrawTime=2.0f)
static FVector	GetTraceStartLocation (const APlayerController *InController)
static FRotator	GetTraceStartRotation (const APlayerController *InController)
static FVector	GetTraceStartEyeLocation (const APawn *Pawn)
static FRotator	GetTraceStartEyeRotation (const APawn *Pawn)
static float	CalculateRatio (const int32 Kills, const int32 Deaths)
static FVector	GetTraceEndLocation (const APlayerController *InController, const float InLength)
static FHitResult	SimpleLineTrace (const APlayerController *InController, const float InLength, const bool bDebug)
static UTexture2D *	TextureFromWidget (UUserWidget *const Widget, const FVector2D &DrawSize)
static EDamageType	DamageTypeToEnum (const UDamageType *DamageType)
static bool	IsDamageTypeNonLethal (const UDamageType *DamageType)
static EDrawDebugTrace::Type	GetDrawDebugType (const bool bDebuggingMode)

Member Function Documentation

CalculateRatio()

float UBaseHelpersBPLib::CalculateRatio ( const int32 Kills, const int32 Deaths )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::CalculateRatio);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if(Deaths == 0)
    {
        return Kills > 0 ? static_cast<float>(Kills) : 0.0f;    
    }
    return static_cast<float>(Kills) / static_cast<float>(Deaths);
}

DamageTypeToEnum()

EDamageType UBaseHelpersBPLib::DamageTypeToEnum ( const UDamageType * DamageType )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::DamageTypeToEnum);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if(DamageType->GetClass() == UBaseDamage::StaticClass())
    {
        return EDamageType::Base;
    }
    if(DamageType->GetClass() == UBulletDamage::StaticClass())
    {
        return EDamageType::Bullet;
    }
    if(DamageType->GetClass() == ULaserDamage::StaticClass())
    {
        return EDamageType::Laser;
    }
    if(DamageType->GetClass() == UPlasmaDamage::StaticClass())
    {
        return EDamageType::Plasma;
    }
    if(DamageType->GetClass() == UElectricalDamage::StaticClass())
    {
        return EDamageType::Electrical;
    }
    if(DamageType->GetClass() == UExplosionDamage::StaticClass())
    {
        return EDamageType::Explosive;
    }
    if(DamageType->GetClass() == UFallDamage::StaticClass())
    {
        return EDamageType::Fall;
    }
    if(DamageType->GetClass() == UFireDamage::StaticClass())
    {
        return EDamageType::Fire;
    }
    if(DamageType->GetClass() == UMeleeDamage::StaticClass())
    {
        return EDamageType::Melee;
    }
    if(DamageType->GetClass() == UNonLethalMeleeDamage::StaticClass())
    {
        return EDamageType::NonLethalMelee;
    }
    if(DamageType->GetClass() == UNonLethalBulletDamage::StaticClass())
    {
        return EDamageType::NonLethalBase;
    }
    if(DamageType->GetClass() == UPoisionDamage::StaticClass())
    {
        return EDamageType::Poison;
    }
    if(DamageType->GetClass() == UWaterDamage::StaticClass())
    {
        return EDamageType::Water;
    }
    return EDamageType::Base;
}

DescribeColorHelper()

static FString UBaseHelpersBPLib::DescribeColorHelper ( const FColor & Color )

inlinestatic

    {
        const int32 MaxColors = GColorList.GetColorsNum();
        for (int32 Idx = 0; Idx < MaxColors; Idx++)
        {
            if (Color == GColorList.GetFColorByIndex(Idx))
            {
                return GColorList.GetColorNameByIndex(Idx);
            }
        }
 
        return FString(TEXT("color"));
    }

FindPlayInEditorAuthorityPlayerController()

APlayerController * UBaseHelpersBPLib::FindPlayInEditorAuthorityPlayerController ( const APlayerController * ClientController )

static

{
#if WITH_EDITOR
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::FindPlayInEditorAuthorityPlayerController);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    const UWorld* ServerWorld = FindPlayInEditorAuthorityWorld();
    if (ServerWorld != nullptr)
    {
        for (FConstPlayerControllerIterator Iterator = ServerWorld->GetPlayerControllerIterator(); Iterator; ++Iterator)
        {
            APlayerController* ServerController = Iterator->Get();
 
            const FUniqueNetIdRepl& ServerPlayerUniqueId = ServerController->PlayerState->GetUniqueId();
            const FUniqueNetIdRepl& ClientPlayerUniqueId = ClientController->PlayerState->GetUniqueId();
 
            if (ServerPlayerUniqueId == ClientPlayerUniqueId)
            {
                return ServerController;
            }
        }
    }
#endif
    return nullptr;
}

FindPlayInEditorAuthorityWorld()

UWorld * UBaseHelpersBPLib::FindPlayInEditorAuthorityWorld ( )

static

Used for Logging Server/Client

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::FindPlayInEditorAuthorityWorld);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
 
    check(GEngine);
    // Find the server world (any PIE world will do, in case they are running without a dedicated server, but the ded. server world is ideal)
    UWorld* ServerWorld = nullptr;
#if WITH_EDITOR
    for (const FWorldContext& WorldContext : GEngine->GetWorldContexts())
    {
        if (WorldContext.WorldType == EWorldType::PIE)
        {
            if (UWorld* TestWorld = WorldContext.World())
            {
                if (WorldContext.RunAsDedicated)
                {
                    // Ideal case
                    ServerWorld = TestWorld;
                    break;
                }
                else if (ServerWorld == nullptr)
                {
                    ServerWorld = TestWorld;
                }
                else
                {
                    // We already have a candidate, see if this one is 'better'
                    if (TestWorld->GetNetMode() < ServerWorld->GetNetMode())
                    {
                        return ServerWorld;
                    }
                }
            }
        }
    }
#endif
    return ServerWorld;
}

GetAllTagsOfCategory()

TArray< FGameplayTag > UBaseHelpersBPLib::GetAllTagsOfCategory ( const FName & Category )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetAllTagsOfCategory);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    TArray<FGameplayTag> ModeTags;
    const UGameplayTagsManager& TagManager = UGameplayTagsManager::Get();
    const FGameplayTagContainer TagContainer = TagManager.RequestGameplayTagChildren(FGameplayTag::RequestGameplayTag(Category));
    TagContainer.GetGameplayTagArray(ModeTags);
    return ModeTags;
}

GetDefaultActorBPClass()

TSubclassOf< AActor > UBaseHelpersBPLib::GetDefaultActorBPClass ( const FString & Location )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetDefaultActorBPClass);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    const TCHAR* LocationText = *Location;
    const ConstructorHelpers::FClassFinder<AActor> DefaultBPClass(LocationText);
    if (!ensure(DefaultBPClass.Class != nullptr)) return nullptr;
    return DefaultBPClass.Class;
}

GetDefaultBPClass()

UClass * UBaseHelpersBPLib::GetDefaultBPClass ( const FString & Location )

static

Only use in contstructor

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetDefaultBPClass);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    const TCHAR* LocationText = *Location;
    const ConstructorHelpers::FClassFinder<UObject> DefaultBPClass(LocationText);
    if (!ensure(DefaultBPClass.Class != nullptr)) return nullptr;
    return DefaultBPClass.Class;
}

GetDefaultDataTable()

UDataTable * UBaseHelpersBPLib::GetDefaultDataTable ( const FString & Location )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetDefaultDataTable);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    const TCHAR* LocationText = *Location;
    const FSoftObjectPath UnitDataTablePath = FSoftObjectPath(LocationText);
    UDataTable* DataTable = Cast<UDataTable>(UnitDataTablePath.ResolveObject());
    if(DataTable != nullptr)
    {
        return DataTable;
    }
    DataTable = Cast<UDataTable>(UnitDataTablePath.TryLoad());
    if(DataTable != nullptr)
    {
        return DataTable;
    }
    UE_LOG(LogBaseHelpers, Warning, TEXT("UBaseHelpersBPLib::GetDefaultDataTable Default DataTable Failed"));
    return nullptr;
}

GetDefaultWidgetBPClass()

TSubclassOf< UUserWidget > UBaseHelpersBPLib::GetDefaultWidgetBPClass ( const FString & Location )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetDefaultWidgetBPClass);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    const TCHAR* LocationText = *Location;
    const ConstructorHelpers::FClassFinder<UUserWidget> DefaultBPClass(LocationText);
    if(DefaultBPClass.Class == nullptr){UE_LOG(LogBaseHelpers, Error, TEXT("Default Widget not found at: %s"), *Location);return nullptr;};
    return DefaultBPClass.Class;
}

GetDrawDebugType()

EDrawDebugTrace::Type UBaseHelpersBPLib::GetDrawDebugType ( const bool bDebuggingMode )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetDrawDebugType);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
 
    if(bDebuggingMode)
    {
        return EDrawDebugTrace::ForDuration;
    }
    else
    {
        return EDrawDebugTrace::None;
    }
}

GetEnumValue()

FString UBaseHelpersBPLib::GetEnumValue ( const FString & BaseString )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetEnumValue);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
 
    FString String;
    FString LeftString;
    BaseString.Split(TEXT("::"), &LeftString, &String);
    return String;
}

GetGameplayTagName()

FString UBaseHelpersBPLib::GetGameplayTagName ( const FGameplayTag & GameplayTag )

static

Gets only the end of a Gameplay Tag

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetGameplayTagName);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    FString LastTagPart = "";
    GameplayTag.GetTagName().ToString().Split(TEXT("."), nullptr, &LastTagPart, ESearchCase::IgnoreCase, ESearchDir::FromEnd);
    return LastTagPart;
}

GetInteraction()

bool UBaseHelpersBPLib::GetInteraction ( FInteractionType & InteractionType, const FInteractionData & InteractionData, const int32 Value )

static

This checks for interactions that are hidden or if the default is set

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetInteraction);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if(InteractionData.bShowDefault && Value == 0)
    {
        return InteractionData.GetDefaultInteraction(InteractionType);
    }
    for(int32 i = 0; i < InteractionData.GetVisibleInteractions().Num(); i++)
    {
        if(InteractionData.GetVisibleInteractions().IsValidIndex(Value))
        {
            InteractionType = InteractionData.GetVisibleInteractions()[Value];
            return true;
        }
    }
    return false;
}

GetInteractionFromType()

bool UBaseHelpersBPLib::GetInteractionFromType ( FInteractionType & InteractionType, const FInteractionData & InteractionData, const EInteractionType Interaction )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetInteractionFromType);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    for(const auto& SingleInteractionType : InteractionData.InteractionTypes)
    {
        if(Interaction == SingleInteractionType.InteractionType)
        {
            InteractionType = SingleInteractionType;
            return true;
        }
    }
    return false;
}

GetPlayerTeamID() [1/2]

int32 UBaseHelpersBPLib::GetPlayerTeamID ( AController * Controller )

static

{
    return GetPlayerTeamIDFromController(Controller);
}

GetPlayerTeamID() [2/2]

int32 UBaseHelpersBPLib::GetPlayerTeamID ( APlayerState * PlayerState )

static

{
    return GetPlayerTeamIDFromState(PlayerState);
}

GetPlayerTeamIDFromController()

int32 UBaseHelpersBPLib::GetPlayerTeamIDFromController ( AController * Controller )

static

{
    int32 TeamID = 0;
    const IGenericTeamAgentInterface* TeamAgentInterface = Cast<IGenericTeamAgentInterface>(Controller->PlayerState);
    if(TeamAgentInterface != nullptr)
    {
        TeamID = TeamAgentInterface->GetGenericTeamId().GetId();
    }
    return TeamID;
}

GetPlayerTeamIDFromState()

int32 UBaseHelpersBPLib::GetPlayerTeamIDFromState ( APlayerState * PlayerState )

static

{
    int32 TeamID = 0;
    const IGenericTeamAgentInterface* TeamAgentInterface = Cast<IGenericTeamAgentInterface>(PlayerState);
    if(TeamAgentInterface != nullptr)
    {
        TeamID = TeamAgentInterface->GetGenericTeamId().GetId();
    }
    return TeamID;
}

GetTraceEndLocation()

FVector UBaseHelpersBPLib::GetTraceEndLocation ( const APlayerController * InController, const float InLength )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetTraceEndLocation);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    return (GetTraceStartRotation(InController).Vector() * InLength) + GetTraceStartLocation(InController);
}

GetTraceStartEyeLocation()

FVector UBaseHelpersBPLib::GetTraceStartEyeLocation ( const APawn * Pawn )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetTraceStartEyeLocation);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if(Pawn == nullptr){return FVector::ZeroVector;}
    FVector Location;
    FRotator Rotation;
    Pawn->GetActorEyesViewPoint(Location, Rotation);
    return Location;
}

GetTraceStartEyeRotation()

FRotator UBaseHelpersBPLib::GetTraceStartEyeRotation ( const APawn * Pawn )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetTraceStartEyeRotation);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if(Pawn == nullptr){return FRotator::ZeroRotator;}
    FVector Location;
    FRotator Rotation;
    Pawn->GetActorEyesViewPoint(Location, Rotation);
    return Rotation;
}

GetTraceStartLocation()

FVector UBaseHelpersBPLib::GetTraceStartLocation ( const APlayerController * InController )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetTraceStartLocation);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if(InController == nullptr || InController->PlayerCameraManager == nullptr){return FVector::ZeroVector;}
    return InController->PlayerCameraManager->GetCameraLocation();
}

GetTraceStartRotation()

FRotator UBaseHelpersBPLib::GetTraceStartRotation ( const APlayerController * InController )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::GetTraceStartRotation);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if(InController == nullptr || InController->PlayerCameraManager == nullptr){return FRotator::ZeroRotator;}
    return InController->PlayerCameraManager->GetCameraRotation();
}

IsDamageTypeNonLethal()

bool UBaseHelpersBPLib::IsDamageTypeNonLethal ( const UDamageType * DamageType )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::IsDamageTypeNonLethal);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if(DamageType->GetClass() == UBaseDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == UBulletDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == ULaserDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == UPlasmaDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == UElectricalDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == UExplosionDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == UFallDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == UFireDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == UMeleeDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == UNonLethalMeleeDamage::StaticClass())
    {
        return true;
    }
    if(DamageType->GetClass() == UNonLethalBulletDamage::StaticClass())
    {
        return true;
    }
    if(DamageType->GetClass() == UPoisionDamage::StaticClass())
    {
        return false;
    }
    if(DamageType->GetClass() == UWaterDamage::StaticClass())
    {
        return false;
    }
    return false;
 
}

LineTraceByChannel()

bool UBaseHelpersBPLib::LineTraceByChannel ( const UObject * WorldContextObject, FHitResult & Hit, const FVector & Start, const FVector & End, const ETraceTypeQuery TraceChannel, const TArray< AActor * > & ActorsToIgnore, const bool bIgnoreSelf, const bool bReturnPhysicalMaterial = false, const bool bTraceComplex = false, const bool bDebug = false, const FLinearColor TraceColor = FLinearColor::Red, const float DrawTime = 2.0f )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::LineTraceByChannel);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    const ECollisionChannel CollisionChannel = UEngineTypes::ConvertToCollisionChannel(TraceChannel);
    const float DrawDebugColorDarkMultiplier = 0.1f;
    const float DrawDebugColorLightMultiplier = 2.0f;
    FCollisionQueryParams Params;
    Params.bDebugQuery = bDebug;
    Params.bTraceComplex = bTraceComplex;
    Params.bReturnPhysicalMaterial = bReturnPhysicalMaterial;
    if (bIgnoreSelf)
    {
        const AActor* IgnoreActor = Cast<AActor>(WorldContextObject);
        if (IgnoreActor)
        {
            Params.AddIgnoredActor(IgnoreActor);
        }
        else
        {
            // find owner
            const UObject* CurrentObject = WorldContextObject;
            while (CurrentObject)
            {
                CurrentObject = CurrentObject->GetOuter();
                IgnoreActor = Cast<AActor>(CurrentObject);
                if (IgnoreActor)
                {
                    Params.AddIgnoredActor(IgnoreActor);
                    break;
                }
            }
        }
    }
    Params.AddIgnoredActors(ActorsToIgnore);
 
    UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull);
    bool const bHit = World ? World->LineTraceSingleByChannel(Hit, Start, End, CollisionChannel, Params) : false;
 
    if(GetDrawDebugType(bDebug) != EDrawDebugTrace::None)
    {
        const bool bPersistent = GetDrawDebugType(bDebug) == EDrawDebugTrace::Persistent;
        const float LifeTime = (GetDrawDebugType(bDebug) == EDrawDebugTrace::ForDuration) ? DrawTime : 0.f;
 
        if (bHit && Hit.bBlockingHit)
        {
            const FLinearColor DarkerColor = FLinearColor(TraceColor.R * DrawDebugColorDarkMultiplier, TraceColor.G * DrawDebugColorDarkMultiplier, TraceColor.B * DrawDebugColorDarkMultiplier, TraceColor.A);
            const FLinearColor LighterColor = FLinearColor((TraceColor.R + 0.1f) * DrawDebugColorLightMultiplier, (TraceColor.G + 0.1f) * DrawDebugColorLightMultiplier, (TraceColor.B + 0.1f) * DrawDebugColorLightMultiplier, TraceColor.A);
            // Red up to the blocking hit, green thereafter
            DrawDebugLine(World, Start, Hit.ImpactPoint, TraceColor.ToFColor(true), bPersistent, LifeTime);
            DrawDebugLine(World, Hit.ImpactPoint, End, LighterColor.ToFColor(true), bPersistent, LifeTime);
            DrawDebugPoint(World, Hit.ImpactPoint, 16.0f, DarkerColor.ToFColor(true), bPersistent, LifeTime);
        }
        else
        {
            // no hit means all red
            DrawDebugLine(World, Start, End, TraceColor.ToFColor(true), bPersistent, LifeTime);
        }
    }
    // DrawDebugLineTraceSingle(World, Start, End, DrawDebugType, bHit, OutHit, TraceColor, TraceHitColor, DrawTime);
    return bHit;
}

PrintToLog()

void UBaseHelpersBPLib::PrintToLog ( const UObject * WorldContextObject, const FString & Message, const bool bWarning = false, const bool bError = false )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::PrintToLog);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    PrintToLogWithCategory(WorldContextObject, LogBaseHelpers, Message, bWarning, bError);
}

PrintToLogWithCategory()

void UBaseHelpersBPLib::PrintToLogWithCategory ( const UObject * WorldContextObject, const FLogCategoryBase & Category, const FString & Message, const bool bWarning = false, const bool bError = false )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::PrintToLogWithCategory);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    FOutputDevice* OutputDevice = GWarn;
    if(OutputDevice == nullptr){return;}
    FString NetModeString;
    switch(WorldContextObject->GetWorld()->GetNetMode())
    {
    case NM_Standalone:
        NetModeString = FString("SDL");
        break;
    case NM_DedicatedServer:
        NetModeString = FString("DServer");
        break;
    case NM_ListenServer:
        NetModeString = FString("LServer");
        break;
    case NM_Client:
        NetModeString = FString("Client");
        break;
    default:
        NetModeString = FString("Unknown");
        break;
    }
    const FString FullMessage = FString::Printf(TEXT("%s: %s"), *NetModeString, *Message);
    if(bError)
    {
        OutputDevice->Log(Category.GetCategoryName(), ELogVerbosity::Error, FullMessage);
    }
    else if(bWarning)
    {
        OutputDevice->Log(Category.GetCategoryName(), ELogVerbosity::Warning, FullMessage);
    }
    else
    {
        OutputDevice->Log(Category.GetCategoryName(), ELogVerbosity::Log, FullMessage);
    }
}

PrintVirtualBoneInfo()

void UBaseHelpersBPLib::PrintVirtualBoneInfo ( USkeletalMeshComponent * SkeletalMeshComponent )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::PrintVirtualBoneInfo);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if(SkeletalMeshComponent == nullptr){return;}
 
    const USkeleton* Skeleton = SkeletalMeshComponent->GetSkeletalMeshAsset()->GetSkeleton();
    if(Skeleton == nullptr){return;}
 
    const FReferenceSkeleton& RefSkeleton = Skeleton->GetReferenceSkeleton();
    const TArray<FVirtualBone>& VirtualBones = Skeleton->GetVirtualBones();
 
    for (const FVirtualBone& VirtualBone : VirtualBones)
    {
        const int32 SourceBoneIndex = RefSkeleton.FindBoneIndex(VirtualBone.SourceBoneName);
        const int32 TargetBoneIndex = RefSkeleton.FindBoneIndex(VirtualBone.TargetBoneName);
 
        if (SourceBoneIndex != INDEX_NONE && TargetBoneIndex != INDEX_NONE)
        {
            UE_LOG(LogTemp, Log, TEXT("Virtual Bone: %s"), *VirtualBone.VirtualBoneName.ToString());
            UE_LOG(LogTemp, Log, TEXT("    Source Bone: %s"), *VirtualBone.SourceBoneName.ToString());
            UE_LOG(LogTemp, Log, TEXT("    Target Bone: %s"), *VirtualBone.TargetBoneName.ToString());
        }
    }
}

RandomCharacterSkills()

FCharacterBaseSkills UBaseHelpersBPLib::RandomCharacterSkills ( const int32 Min, const int32 Max )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::RandomCharacterSkills);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    FCharacterBaseSkills CharacterTraits;
    const float MinFloat = Min * 1000.0f;
    const float MaxFloat = Max * 1000.0f;
    const float Agility = UKismetMathLibrary::RandomFloatInRange(MinFloat, MaxFloat);
    CharacterTraits.AddAgilityXP(Agility);
    const float Charisma = UKismetMathLibrary::RandomFloatInRange(MinFloat, MaxFloat);
    CharacterTraits.AddCharismaXP(Charisma);
    const float Endurance = UKismetMathLibrary::RandomFloatInRange(MinFloat, MaxFloat);
    CharacterTraits.AddEnduranceXP(Endurance);
    const float Intelligence = UKismetMathLibrary::RandomFloatInRange(MinFloat, MaxFloat);
    CharacterTraits.AddIntelligenceXP(Intelligence);
    const float Luck = UKismetMathLibrary::RandomFloatInRange(MinFloat, MaxFloat);
    CharacterTraits.AddLuckXP(Luck);
    const float Perception = UKismetMathLibrary::RandomFloatInRange(MinFloat, MaxFloat);
    CharacterTraits.AddPerceptionXP(Perception);
    const float Stealth = UKismetMathLibrary::RandomFloatInRange(MinFloat, MaxFloat);
    CharacterTraits.AddStealthXP(Stealth);
    const float Strength = UKismetMathLibrary::RandomFloatInRange(MinFloat, MaxFloat);
    CharacterTraits.AddStrengthXP(Strength);
    const float Weapon = UKismetMathLibrary::RandomFloatInRange(MinFloat, MaxFloat);
    CharacterTraits.AddWeaponSkillXP(Weapon);
    return CharacterTraits;
}

SimpleLineTrace()

FHitResult UBaseHelpersBPLib::SimpleLineTrace ( const APlayerController * InController, const float InLength, const bool bDebug )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::SimpleLineTrace);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    FHitResult Hit;
    TArray<AActor*> ActorsToIgnore;
    if(InController->GetPawn() != nullptr){ActorsToIgnore.Add(InController->GetPawn());}
    UKismetSystemLibrary::LineTraceSingle(InController, GetTraceStartLocation(InController), GetTraceEndLocation(InController, InLength),
        UEngineTypes::ConvertToTraceType(ECC_EngineTraceChannel1), false, ActorsToIgnore, GetDrawDebugType(bDebug), Hit,
        true, FLinearColor::Blue, FLinearColor::Black, 2.0f);
    return Hit;
 
}

SoundNameFromSource()

FName UBaseHelpersBPLib::SoundNameFromSource ( const ESoundSource SoundSource )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::SoundNameFromSource);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    switch (SoundSource)
    {
    case ESoundSource::Alarms:
        return FName("Alarms");
    case ESoundSource::Climbing:
        return FName("Climbing");
    case ESoundSource::Distractions:
        return FName("Distractions");
    case ESoundSource::Door:
        return FName("Door");
    case ESoundSource::Footstep:
        return FName("Footstep");
    case ESoundSource::Gadget:
        return FName("Gadget");
    case ESoundSource::Interaction:
        return FName("Interaction");
    case ESoundSource::Jump:
        return FName("Jump");
    case ESoundSource::Melee:
        return FName("Melee");
    case ESoundSource::MeleeWeapon:
        return FName("MeleeWeapon");
    case ESoundSource::Reload:
        return FName("Reload");
    case ESoundSource::Voice:
        return FName("Voice");
    case ESoundSource::BulletFire:
        return FName("BulletFire");
    case ESoundSource::BulletImpact:
        return FName("BulletImpact");
    case ESoundSource::DryFire:
        return FName("DryFire");
    case ESoundSource::EnvironmentalHazards:
        return FName("EnvironmentalHazards");
    case ESoundSource::Explosion:
        return FName("Explosion");
    case ESoundSource::SilencedBulletFire:
        return FName("SilencedBulletFire");
    default:
        UE_LOG(LogBaseHelpers, Error, TEXT("SoundName from Source Failed"));
        return FName("default");
    }
}

SoundSourceFromName()

ESoundSource UBaseHelpersBPLib::SoundSourceFromName ( const FName & SoundName )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::SoundSourceFromName);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if (SoundName == FName("Alarms"))
    {
        return ESoundSource::Alarms;
    }
    if (SoundName == FName("Climbing"))
    {
        return ESoundSource::Climbing;
    }
    if (SoundName == FName("Distractions"))
    {
        return ESoundSource::Distractions;
    }
    if (SoundName == FName("Door"))
    {
        return ESoundSource::Door;
    }
    if (SoundName == FName("Footstep"))
    {
        return ESoundSource::Footstep;
    }
    if (SoundName == FName("Gadget"))
    {
        return ESoundSource::Gadget;
    }
    if (SoundName == FName("Interaction"))
    {
        return ESoundSource::Interaction;
    }
    if (SoundName == FName("Jump"))
    {
        return ESoundSource::Jump;
    }
    if (SoundName == FName("Melee"))
    {
        return ESoundSource::Melee;
    }
    if (SoundName == FName("MeleeWeapon"))
    {
        return ESoundSource::MeleeWeapon;
    }
    if (SoundName == FName("Reload"))
    {
        return ESoundSource::Reload;
    }
    if (SoundName == FName("Voice"))
    {
        return ESoundSource::Voice;
    }
    if (SoundName == FName("BulletFire"))
    {
        return ESoundSource::BulletFire;
    }
    if (SoundName == FName("BulletImpact"))
    {
        return ESoundSource::BulletImpact;
    }
    
    if (SoundName == FName("DryFire"))
    {
        return ESoundSource::DryFire;
    }
    if (SoundName == FName("EnvironmentalHazards"))
    {
        return ESoundSource::EnvironmentalHazards;
    }
    if (SoundName == FName("Explosion"))
    {
        return ESoundSource::Explosion;
    }
    if (SoundName == FName("SilencedBulletFire"))
    {
        return ESoundSource::SilencedBulletFire;
    }
    UE_LOG(LogBaseHelpers, Error, TEXT("SoundName from Source Failed"));
    return ESoundSource::Interaction; // default case
}

TextureFromWidget()

UTexture2D * UBaseHelpersBPLib::TextureFromWidget ( UUserWidget *const Widget, const FVector2D & DrawSize )

static

Renders a UMG Widget to a texture with the specified size.

Parameters

Widget	The widget to be rendered.
DrawSize	The size to render the Widget to. Also will be the texture size.

Returns

The texture containing the rendered widget.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::TextureFromWidget);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    if (FSlateApplication::IsInitialized()
        && Widget != NULL && Widget->IsValidLowLevel()
        && DrawSize.X >= 1 && DrawSize.Y >= 1)
    {
        TSharedPtr<SWidget> SlateWidget(Widget->TakeWidget());
        if (!SlateWidget.IsValid()) return NULL;
        TSharedPtr<FWidgetRenderer> WidgetRenderer = MakeShareable(new FWidgetRenderer(true));
        if (!WidgetRenderer.IsValid()) return NULL;
 
        UTextureRenderTarget2D *TextureRenderTarget = WidgetRenderer->DrawWidget(SlateWidget.ToSharedRef(), DrawSize);
        // Creates Texture2D to store RenderTexture content
        UTexture2D *Texture = UTexture2D::CreateTransient(DrawSize.X, DrawSize.Y, PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA
        Texture->MipGenSettings = TMGS_NoMipmaps;
#endif
 
        // Lock and copies the data between the textures
        TArray<FColor> SurfData;
        FRenderTarget *RenderTarget = TextureRenderTarget->GameThread_GetRenderTargetResource();
        RenderTarget->ReadPixels(SurfData);
    
        void* TextureData = Texture->GetPlatformData()->Mips[0].BulkData.Lock(LOCK_READ_WRITE);
        const int32 TextureDataSize = SurfData.Num() * 4;
        FMemory::Memcpy(TextureData, SurfData.GetData(), TextureDataSize);
        Texture->GetPlatformData()->Mips[0].BulkData.Unlock();
        Texture->UpdateResource();
 
        // Free resources
        SurfData.Empty();
        TextureRenderTarget->ConditionalBeginDestroy();
        SlateWidget.Reset();
        WidgetRenderer.Reset();
 
        return Texture;
    }
    return NULL;
}

ToggleInputMode()

void UBaseHelpersBPLib::ToggleInputMode ( APlayerController * InController, const bool bForceGameOnly = false, const bool bForceUI = false, class UUserWidget * WidgetToFocus = nullptr )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::ToggleInputMode);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
    const FInputModeGameOnly InputModeGameOnly;
    const FInputModeGameAndUI InputModeUIOnly;
    if(WidgetToFocus != nullptr)
    {
        // TSharedPtr<SWidget> SlateWidget = WidgetToFocus->GetSlateWidgetFromName();
        // InputModeUIOnly.SetWidgetToFocus(SlateWidget);
    }
    if(InController->bShowMouseCursor)
    {
        InController->SetInputMode(InputModeGameOnly);
    }
    else
    {
        InController->SetInputMode(InputModeUIOnly);
    }
    InController->bShowMouseCursor = !InController->bShowMouseCursor;
    if(bForceGameOnly)
    {
        InController->SetInputMode(InputModeGameOnly);
        InController->bShowMouseCursor = false;
    }
    if(bForceUI)
    {
        InController->SetInputMode(InputModeGameOnly);
        InController->bShowMouseCursor = true;
    }
}

ToggleWidgetVisibility()

void UBaseHelpersBPLib::ToggleWidgetVisibility ( UUserWidget * Widget, const bool bForceSetVisible = false, const bool bForceSetCollapsed = false )

static

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UBaseHelpersBPLib::ToggleWidgetVisibility);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_BPLib);
 
    const ESlateVisibility CurrentVisibility = Widget->GetVisibility();
    ESlateVisibility TargetVisibility;
    if(CurrentVisibility == ESlateVisibility::Visible || CurrentVisibility == ESlateVisibility::HitTestInvisible || CurrentVisibility == ESlateVisibility::SelfHitTestInvisible)
    {
        TargetVisibility = ESlateVisibility::Collapsed;
    }
    else
    {
        TargetVisibility = ESlateVisibility::Visible;
    }
    if(bForceSetVisible)
    {
        TargetVisibility = ESlateVisibility::Visible;
    }
    if(bForceSetCollapsed)
    {
        TargetVisibility = ESlateVisibility::Collapsed;
    }
    Widget->SetVisibility(TargetVisibility);
}

---

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

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Public/BPLib/BaseHelpersBPLib.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Private/BPLib/BaseHelpersBPLib.cpp