Unreal Engine Helpful Stuff

"DeveloperSettings" //For developer settings used to add custom options to Project Settings

"AudioMixer" //For Quartz system

"MovieScene" //For level sequence systems

"LevelSequence" //For level sequence systems

"UMG" //For using UI based classes

#include "Misc/UObjectToken.h" //For FUObjectToken 

//The WorldContext meta tag auto-assigns the Blueprint caller's WorldContext to the WorldContextObject parameter

UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"))

void AddMessageLog(UObject* WorldContextObject)

{

TSharedRef<FTokenizedMessage> log = FTokenizedMessage::Create(EMessageSeverity::Warning, FText::FromString("Message"));

if (IsValid(WorldContextObject))

{

//This can be used to add a hyperlink to the Blueprint where this function was called

log->AddToken(FUObjectToken::Create(WorldContext->GetClass(), FText::FromString(TEXT("Additional Message"))));

}

FMessageLog(TEXT("PIE")).AddMessage(log);

FMessageLog(TEXT("PIE")).Open();

}

//Optional UFUNCTION(BlueprintCallable)

void PrintBlueprintCallstack()

{

FString callStack = FFrame::GetScriptCallstack();

UE_LOG(LogTemp, Error, TEXT("%s"), callStack);

}

#if !UE_BUILD_SHIPPING

void RegisterConsoleComand()

{

IConsoleManager::Get().RegisterConsoleCommand(TEXT("TextYouType"), TEXT("Help tip."), FConsoleCommandDelegate::CreateUObject(this, &MyClass::Exec_Command), ECVF_Default);

}

void UnregisterConsoleCommand()

{

IConsoleManager::Get().UnregisterConsoleObject(TEXT("TextYouType"));

}

UFUNCTION()

void Command()

{

UE_LOG(LogTemp, Error, TEXT("Wahoo!"));

}

#endif

//This function can be used to create an equals Blueprint node that only allows you to select assets that match your class.

UFUNCTION(BlueprintPure, meta = (DisplayName = "Equal (MyClass)", CompactNodeTitle = "==", Keywords = "== equal"))

static bool EqualMyClass(MyClass* A, MyClass* B)

{

if (A == B)

{

return true;

}

return false;

}

//Make sure this UObject is created using NewObject<MyClass>(this) where "this" will be the Outer and have a valid world such as an Actor or subsystem.

virtual UWorld* GetWorld() const override

{

if (IsTemplate() || !GetOuter())

{

return nullptr;

}

return GetOuter()->GetWorld();

}

UENUM(BlueprintType)

enum ELegacyEnum : uint8

{

SomeEngineEnumsAreLikeThis

}

UPROPERTY(EditAnywhere)

TEnumAsByte<ELegacyEnum> needToBeStoredLikeThis;

"AudioMixer" //Module dependency for Quartz system in plugins

#include "Quartz/AudioMixerClockHandle.h"

void CreateNewQuartzClock(UQuartzClockHandle* clockHandle, int timeSignatureNumerator, float bpm)

{

//Get the Quartz subsystem

UQuartzSubsystem* quartz = GetWorld()->GetSubsystem<UQuartzSubsystem>();

if (!IsValid(quartz))

{

return;

}

//Checking if a clock has already been created that we want to reuse

if (IsValid(clockHandle))

{

//Stopping the clock allows arg 2 to clear any pending QuartzCommandEventBPs

clockHandle->StopClock(this, true, clockHandle);

}

FQuartzTimeSignature timeSignature;

timeSignature.BeatType = EQuartzTimeSignatureQuantization::QuarterNote;

timeSignature.NumBeats = timeSignatureNumerator;

FQuartzClockSettings settings;

settings.TimeSignature = timeSignature;

//If the FName in arg 2 matches an existing clock, CreateNewClock will return that clock instead of creating a new one. 

//Arg 4 indicates you want to modify an existing clock's setting

clockHandle = quartz->CreateNewClock(this, FName(TEXT("MusicClock")), settings, true);

clockHandle->SetBeatsPerMinute(this, FQuartzQuantizationBoundary(), FOnQuartzCommandEventBP(), clockHandle, bpm);

//Subscribe to receive synchronized quantization events from this clock

FOnQuartzMetronomeEventBP command;

command.BindUFunction(this, FName(TEXT("ReceiveClockCallback")));

clockHandle->SubscribeToQuantizationEvent(this, EQuartzCommandQuantization::Beat, command, clockHandle);

clockHandle->StartClock(this, clockHandle);

}

UFUNCTION()

void ReceiveClockCallback(FName ClockName, EQuartzCommandQuantization QuantizationType, int32 NumBars, int32 Beat, float BeatFraction)

{

GEngine->AddOnScreenDebugMessage(0, 10, FColor::Green, FString::FromInt(Beat) + " : " + FString::FromInt(NumBars));

}

"AudioMixer" //Module dependency for Quartz system in plugins

#include "Quartz/AudioMixerClockHandle.h"

void SynchronizedEventExample(UAudioComponent* audioComponent, UQuartzClockHandle* clockHandle, float relativeSynchTime, float fadeInTime, EAudioFaderCurve fadeInCurve)

{

//FQuartzQuantizationBoundary defines the timing when your event will be fired. These settings fire based on seconds rather than on a tempo quantized value because we calculate the exact timing separately for flexibility.

FQuartzQuantizationBoundary boundary;

boundary.bFireOnClockStart = false;

boundary.Quantization = EQuartzCommandQuantization::Tick;

boundary.Multiplier = relativeSynchTime / clockHandle->GetSecondsPerTick(this);

boundary.CountingReferencePoint = EQuarztQuantizationReference::CurrentTimeRelative;

//FOnQuartzCommandEventBP will call a UFUNCTION for ALL Quartz commands. This means the receiver must evaluate which commands it wants to listen to.

FOnQuartzCommandEventBP command;

command.BindUFunction(this, FName(TEXT("MyFunction")));

//Reset clock if modifications not done elsewhere for the next piece of music. For how to modify, see CreateNewQuartzClock

clockHandle->ResetTransportQuantized(this, boundary, command, clockHandle);

//Schedule the audio component play timing.

audioComponent->PlayQuantized(this, clockHandle, boundary, command, 0, fadeInTime, 1, fadeInCurve);

//Use below when you need to cancel an audio component's scheduled play

audioComponent->Stop();

}

UFUNCTION()

void MyFunction(EQuartzCommandDelegateSubType EventType)

{

if (EventType != EQuartzCommandDelegateSubType::CommandOnStarted)

{

return;

}

}