DebugDisplay

DebugDisplay

#Overview

name: DebugDisplay

The value of this variable can be defined or overridden in .ini config files. 1 .ini config file referencing this setting variable.

It is referenced in 63 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of DebugDisplay is to control and manage the display of debug information in the Unreal Engine. It is primarily used for debugging and visualizing various aspects of the game or application during development.

DebugDisplay is relied upon by multiple Unreal Engine subsystems, plugins, and modules, including:

  1. Camera system (PlayerCameraManager, CameraModifiers)
  2. Character and Pawn systems
  3. Player Controller and Input systems
  4. Animation system
  5. Physics and Movement systems
  6. Ability System
  7. Audio Streaming system
  8. HUD and UI systems

The value of this variable is typically set through the game’s configuration files or programmatically during runtime. It is often modified using the ShowDebug command or through the HUD settings.

DebugDisplay interacts with other variables and systems, such as:

  1. bShowDebugInfo: A boolean flag that enables or disables debug display
  2. Various debug categories (e.g., “AbilitySystem”, “Physics”, “Camera”)
  3. Canvas and DisplayDebugManager for rendering debug information

Developers should be aware of the following when using DebugDisplay:

  1. It can impact performance when enabled, especially with multiple debug categories active
  2. Debug information may reveal sensitive data or implementation details
  3. It’s primarily intended for development and should be disabled or removed in shipping builds

Best practices for using DebugDisplay include:

  1. Use it selectively and disable when not needed to maintain performance
  2. Organize debug information into logical categories for easier navigation
  3. Ensure debug displays are clear, concise, and relevant to the current development task
  4. Use conditional compilation to remove debug code in shipping builds
  5. Consider creating custom debug categories for project-specific information
  6. Regularly review and update debug displays to ensure they remain useful and accurate

By following these guidelines, developers can effectively use DebugDisplay to improve their development process and troubleshoot issues in Unreal Engine projects.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseGame.ini:166, section: [/Script/Engine.HUD]

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/Cameras/GameplayCameras/Source/GameplayCameras/Private/Animations/CameraAnimationCameraModifier.cpp:201

Scope (from outer to inner):

file
function     void UCameraAnimationCameraModifier::DisplayDebug

Source code excerpt:

}

void UCameraAnimationCameraModifier::DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	Canvas->SetDrawColor(FColor::Yellow);
	UFont* DrawFont = GEngine->GetSmallFont();

	int Indentation = 1;
	int LineNumber = FMath::CeilToInt(YPos / YL);

#Loc: <Workspace>/Engine/Plugins/Cameras/GameplayCameras/Source/GameplayCameras/Private/Animations/CameraAnimationCameraModifier.cpp:241

Scope (from outer to inner):

file
function     void UCameraAnimationCameraModifier::DisplayDebug

Source code excerpt:

	YPos = LineNumber * YL;

	Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);
}

int32 UCameraAnimationCameraModifier::FindInactiveCameraAnimation()
{
	for (int32 Index = 0; Index < ActiveAnimations.Num(); ++Index)
	{

#Loc: <Workspace>/Engine/Plugins/Cameras/GameplayCameras/Source/GameplayCameras/Public/Animations/CameraAnimationCameraModifier.h:227

Scope (from outer to inner):

file
class        class UCameraAnimationCameraModifier : public UCameraModifier

Source code excerpt:

	// UCameraModifier interface
	virtual bool ModifyCamera(float DeltaTime, FMinimalViewInfo& InOutPOV) override;
	virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;

public:

	UFUNCTION(BlueprintPure, Category="Camera Animation", meta=(WorldContext="WorldContextObject"))
	static UCameraAnimationCameraModifier* GetCameraAnimationCameraModifier(const UObject* WorldContextObject, int32 PlayerIndex);

#Loc: <Workspace>/Engine/Plugins/Experimental/ChaosVehiclesPlugin/Source/ChaosVehicles/Private/WheeledVehiclePawn.cpp:27

Scope (from outer to inner):

file
function     void AWheeledVehiclePawn::DisplayDebug

Source code excerpt:

}

void AWheeledVehiclePawn::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	static FName NAME_Vehicle = FName(TEXT("Vehicle"));

	Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);
}

class UChaosVehicleMovementComponent* AWheeledVehiclePawn::GetVehicleMovementComponent() const
{
	return VehicleMovementComponent;
}

#Loc: <Workspace>/Engine/Plugins/Experimental/ChaosVehiclesPlugin/Source/ChaosVehicles/Public/WheeledVehiclePawn.h:41

Scope (from outer to inner):

file
class        class AWheeledVehiclePawn : public APawn

Source code excerpt:


	//~ Begin AActor Interface
	virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
	//~ End Actor Interface

	/** Returns Mesh subobject **/
	class USkeletalMeshComponent* GetMesh() const { return Mesh; }

	/** Returns VehicleMovement subobject **/

#Loc: <Workspace>/Engine/Plugins/Experimental/GameplayTargetingSystem/Source/GameplayTargetingSystem/Private/TargetingSystem/TargetingSubsystem.cpp:797

Scope (from outer to inner):

file
function     void UTargetingSubsystem::DisplayDebug

Source code excerpt:



void UTargetingSubsystem::DisplayDebug(class UCanvas* Canvas, const class FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	FTargetingDebugInfo DebugInfo;

	DebugInfo.bPrintToLog = TargetingSystemCVars::bPrintTargetingDebugToLog;
	DebugInfo.Canvas = Canvas;
	DebugInfo.XPos = 0.f;

#Loc: <Workspace>/Engine/Plugins/Experimental/GameplayTargetingSystem/Source/GameplayTargetingSystem/Public/TargetingSystem/TargetingSubsystem.h:228

Scope (from outer to inner):

file
class        class UTargetingSubsystem : public UGameInstanceSubsystem, public FTickableGameObject, public FSelfRegisteringExec

Source code excerpt:


private:
	void DisplayDebug(class UCanvas* Canvas, const class FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);
	void Debug_Internal(struct FTargetingDebugInfo& Info);
	void DebugForHandle_Internal(FTargetingRequestHandle& Handle, struct FTargetingDebugInfo& Info);
	void AccumulateScreenPos(FTargetingDebugInfo& Info);

	void AddDebugTrackedImmediateTargetRequests(FTargetingRequestHandle TargetingHandle) const;
	void AddDebugTrackedAsyncTargetRequests(FTargetingRequestHandle TargetingHandle) const;

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Graph/PCGGraphExecutor.cpp:996

Scope (from outer to inner):

file
function     void FPCGGraphExecutor::Execute
lambda-function

Source code excerpt:

				// Execute debug display code as needed - done here because it needs to be done on the main thread
				// Additional note: this needs to be executed before the StoreResults since debugging might cancel further tasks
				ActiveTask.Element->DebugDisplay(ActiveTask.Context.Get());

				if (UPCGComponent* SourceComponent = ActiveTask.Context->SourceComponent.Get())
				{
					if (ActiveTask.StackIndex != INDEX_NONE)
					{
						const FPCGStack* Stack = ActiveTask.StackContext->GetStack(ActiveTask.StackIndex);

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/PCGElement.cpp:289

Scope (from outer to inner):

file
function     void IPCGElement::DebugDisplay

Source code excerpt:


#if WITH_EDITOR
void IPCGElement::DebugDisplay(FPCGContext* Context) const
{
	// Check Debug flag.
	const UPCGSettingsInterface* SettingsInterface = Context->GetInputSettingsInterface();
	if (!SettingsInterface || !SettingsInterface->bDebug)
	{
		return;

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Public/PCGElement.h:104

Scope (from outer to inner):

file
class        class IPCGElement

Source code excerpt:


	/** Note: must be called from the main thread. */
	void DebugDisplay(FPCGContext* Context) const;
#endif

protected:
	/** This function will be called once and once only, at the beginning of an execution */
	void PreExecute(FPCGContext* Context) const;
	/** The prepare data phase is one where it is more likely to be able to multithread */

#Loc: <Workspace>/Engine/Plugins/Runtime/GameplayAbilities/Source/GameplayAbilities/Private/AbilitySystemComponent.cpp:2323

Scope (from outer to inner):

file
function     void UAbilitySystemComponent::DisplayDebug

Source code excerpt:

}

void UAbilitySystemComponent::DisplayDebug(class UCanvas* Canvas, const class FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	FAbilitySystemComponentDebugInfo DebugInfo;

	if (DebugDisplay.IsDisplayOn(FName(TEXT("Attributes"))))
	{
		DebugInfo.bShowAbilities = false;
		DebugInfo.bShowAttributes = true;
		DebugInfo.bShowGameplayEffects = false;
	}
	if (DebugDisplay.IsDisplayOn(FName(TEXT("Ability"))))
	{
		DebugInfo.bShowAbilities = true;
		DebugInfo.bShowAttributes = false;
		DebugInfo.bShowGameplayEffects = false;
	}
	else if (DebugDisplay.IsDisplayOn(FName(TEXT("GameplayEffects"))))
	{
		DebugInfo.bShowAbilities = false;
		DebugInfo.bShowAttributes = false;
		DebugInfo.bShowGameplayEffects = true;
	}

#Loc: <Workspace>/Engine/Plugins/Runtime/GameplayAbilities/Source/GameplayAbilities/Public/AbilitySystemComponent.h:1266

Scope (from outer to inner):

file
class        class UAbilitySystemComponent : public UGameplayTasksComponent, public IGameplayTagAssetInterface, public IAbilitySystemReplicationProxyInterface

Source code excerpt:

	static void OnShowDebugInfo(AHUD* HUD, UCanvas* Canvas, const FDebugDisplayInfo& DisplayInfo, float& YL, float& YPos);

	virtual void DisplayDebug(class UCanvas* Canvas, const class FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);
	virtual void PrintDebug();

	void AccumulateScreenPos(FAbilitySystemComponentDebugInfo& Info);
	virtual void Debug_Internal(struct FAbilitySystemComponentDebugInfo& Info);
	void DebugLine(struct FAbilitySystemComponentDebugInfo& Info, FString Str, float XOffset, float YOffset, int32 MinTextRowsToAdvance = 0);
	FString CleanupName(FString Str);

#Loc: <Workspace>/Engine/Source/Runtime/AIModule/Classes/AIController.h:351

Scope: file

Source code excerpt:

public:
	AIMODULE_API virtual bool ShouldPostponePathUpdates() const override;
	AIMODULE_API virtual void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;

#if ENABLE_VISUAL_LOG
	AIMODULE_API virtual void GrabDebugSnapshot(FVisualLogEntry* Snapshot) const override;
#endif

	AIMODULE_API virtual void Reset() override;

#Loc: <Workspace>/Engine/Source/Runtime/AIModule/Classes/Navigation/PathFollowingComponent.h:371

Scope (from outer to inner):

file
class        class UPathFollowingComponent : public UActorComponent, public IAIResourceInterface, public IPathFollowingAgentInterface

Source code excerpt:

	AIMODULE_API virtual FString GetDebugString() const;

	AIMODULE_API virtual void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) const;
#if ENABLE_VISUAL_LOG
	AIMODULE_API virtual void DescribeSelfToVisLog(struct FVisualLogEntry* Snapshot) const;
#endif // ENABLE_VISUAL_LOG

	/** called when moving agent collides with another actor */
	UFUNCTION()

#Loc: <Workspace>/Engine/Source/Runtime/AIModule/Private/AIController.cpp:116

Scope (from outer to inner):

file
function     void AAIController::DisplayDebug

Source code excerpt:

}

void AAIController::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);

	if (DebugDisplay.IsDisplayOn(NAME_AI))
	{
		if (PathFollowingComponent)
		{
			PathFollowingComponent->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
		}

		AActor* FocusActor = GetFocusActor();
		if (FocusActor)
		{
			FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;

#Loc: <Workspace>/Engine/Source/Runtime/AIModule/Private/Navigation/PathFollowingComponent.cpp:1754

Scope (from outer to inner):

file
function     void UPathFollowingComponent::DisplayDebug

Source code excerpt:

}

void UPathFollowingComponent::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) const
{
	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
	DisplayDebugManager.SetDrawColor(FColor::Blue);
	DisplayDebugManager.DrawString(FString::Printf(TEXT("  Move status: %s"), *GetStatusDesc()));

	if (Status == EPathFollowingStatus::Moving)

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Animation/AnimInstance.h:1338

Scope (from outer to inner):

file
class        class UAnimInstance : public UObject

Source code excerpt:


	// Debug output for this anim instance. Info for SyncGroups, Graph, Montages, etc.
	ENGINE_API void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);

	// Display debug info about AnimInstance. Can be overridden to add custom info from child classes.
	ENGINE_API virtual void DisplayDebugInstance(FDisplayDebugManager& DisplayDebugManager, float& Indent);

	/** Reset any dynamics running simulation-style updates (e.g. on teleport, time skip etc.) */
	UFUNCTION(BlueprintCallable, Category = "Animation|Dynamics")

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Camera/CameraModifier.h:74

Scope (from outer to inner):

file
class        class UCameraModifier : public UObject

Source code excerpt:

	 * Allows camera modifiers to output debug text during "showdebug camera"
	 * @param Canvas - The canvas to write debug info on.
	 * @param DebugDisplay - Meta data about the current debug display.
	 * @param YL - Vertical spacing.
	 * @param YPos - Current vertical space to start writing.
	 */
	ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);

	/** 
	 * Allows any custom initialization. Called immediately after creation.
	 * @param Camera - The camera this modifier should be associated with.
	 */
	ENGINE_API virtual void AddedToCamera( APlayerCameraManager* Camera );
	
	/**

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Camera/CameraModifier_CameraShake.h:198

Scope (from outer to inner):

file
class        class UCameraModifier_CameraShake : public UCameraModifier

Source code excerpt:

	//~ Begin UCameraModifer Interface
	ENGINE_API virtual bool ModifyCamera(float DeltaTime, struct FMinimalViewInfo& InOutPOV) override;
	ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
	//~ End UCameraModifer Interface

protected:

	/** List of active CameraShake instances */
	UPROPERTY()

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Camera/CameraModifier_CameraShake.h:221

Scope (from outer to inner):

file
class        class UCameraModifier_CameraShake : public UCameraModifier

Source code excerpt:

	ENGINE_API void AddCameraShakeDebugData(FActiveCameraShakeInfo& ShakeInfo);
	ENGINE_API void RemoveCameraShakeDebugData(const FActiveCameraShakeInfo& ShakeInfo);
	ENGINE_API void DisplayDebugGraphs(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay);

	/** List of debug data for camera shakes */
	TArray<FCameraShakeDebugData> DebugShakes;
	/** Whether we are currently recording camera shake debug info */
	bool bRecordDebugData;
#endif

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Camera/PlayerCameraManager.h:569

Scope (from outer to inner):

file
class        class APlayerCameraManager : public AActor

Source code excerpt:

	ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
	ENGINE_API virtual void Destroyed() override;
	ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
	ENGINE_API virtual void ApplyWorldOffset(const FVector& InOffset, bool bWorldShift) override;
	//~ End AActor Interface

	/** Static.  Plays an in-world camera shake that affects all nearby players, with radial distance-based attenuation.
	 * @param InWorld - World context.
	 * @param Shake - Camera shake asset to use.

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/GameFramework/Actor.h:4165

Scope: file

Source code excerpt:

	 * @param Canvas			Canvas to draw on
	 *
	 * @param DebugDisplay		Contains information about what debug data to display
	 *
	 * @param YL				[in]	Height of the previously drawn line.
	 *							[out]	Height of the last line drawn by this function.
	 *
	 * @param YPos				[in]	Y position on Canvas for the previously drawn line. YPos += YL, gives position to draw text for next debug line.
	 *							[out]	Y position on Canvas for the last line drawn by this function.
	 */
	ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const class FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);

	/** Retrieves actor's name used for logging, or string "NULL" if Actor is null */
	static FString GetDebugName(const AActor* Actor) { return Actor ? Actor->GetName() : TEXT("NULL"); }

#if !UE_BUILD_SHIPPING
	/** Delegate for globally hooking ProccessEvent calls - used by a non-public testing plugin */
	static ENGINE_API FOnProcessEvent ProcessEventDelegate;
#endif

#if !UE_STRIP_DEPRECATED_PROPERTIES

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/GameFramework/Character.h:662

Scope (from outer to inner):

file
class        class ACharacter : public APawn

Source code excerpt:

	ENGINE_API virtual void UnPossessed() override;
	ENGINE_API virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
	ENGINE_API virtual void RecalculateBaseEyeHeight() override;
	ENGINE_API virtual void UpdateNavigationRelevance() override;
	//~ End APawn Interface

	/** Apply momentum caused by damage. */
	ENGINE_API virtual void ApplyDamageMomentum(float DamageTaken, FDamageEvent const& DamageEvent, APawn* PawnInstigator, AActor* DamageCauser);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/GameFramework/CharacterMovementComponent.h:1835

Scope: file

Source code excerpt:

	 *
	 * @param Canvas - Canvas to draw on
	 * @param DebugDisplay - Contains information about what debug data to display
	 * @param YL - Height of the current font
	 * @param YPos - Y position on Canvas. YPos += YL, gives position to draw text for next debug line.
	 */
	ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);

	/**
	 * Draw in-world debug information for character movement (called with p.VisualizeMovement > 0).
	 */
	ENGINE_API virtual float VisualizeMovement() const;

	/** Check if swimming pawn just ran into edge of the pool and should jump out. */
	ENGINE_API virtual bool CheckWaterJump(FVector CheckPoint, FVector& WallNormal);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/GameFramework/Controller.h:213

Scope (from outer to inner):

file
class        class AController : public AActor, public INavAgentInterface

Source code excerpt:

	ENGINE_API virtual void TickActor( float DeltaTime, enum ELevelTick TickType, FActorTickFunction& ThisTickFunction ) override;
	ENGINE_API virtual void K2_DestroyActor() override;
	ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
	ENGINE_API virtual void GetActorEyesViewPoint( FVector& out_Location, FRotator& out_Rotation ) const override;
	ENGINE_API virtual FString GetHumanReadableName() const override;

	/** Overridden to create the player replication info and perform other mundane initialization tasks. */
	ENGINE_API virtual void PostInitializeComponents() override;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/GameFramework/HUD.h:86

Scope (from outer to inner):

file
class        class AHUD : public AActor

Source code excerpt:

	/** Array of names specifying what debug info to display for viewtarget actor. */
	UPROPERTY(globalconfig)
	TArray<FName> DebugDisplay;

	/** Array of names specifying what subsets of debug info to display for viewtarget actor. */
	UPROPERTY(globalconfig)
	TArray<FName> ToggledDebugCategories;

protected:

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/GameFramework/Pawn.h:269

Scope (from outer to inner):

file
class        class APawn : public AActor, public INavAgentInterface

Source code excerpt:

	ENGINE_API virtual void PostNetReceiveLocationAndRotation() override;
	ENGINE_API virtual void PostNetReceiveVelocity(const FVector& NewVelocity) override;
	ENGINE_API virtual void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
	ENGINE_API virtual void GetActorEyesViewPoint( FVector& Location, FRotator& Rotation ) const override;
	ENGINE_API virtual void OutsideWorldBounds() override;
	ENGINE_API virtual void BeginPlay() override;
	ENGINE_API virtual void Destroyed() override;
	ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
	ENGINE_API virtual void PreInitializeComponents() override;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/GameFramework/PlayerController.h:1829

Scope (from outer to inner):

file
class        class APlayerController : public AController, public IWorldPartitionStreamingSourceProvider

Source code excerpt:

	ENGINE_API virtual class UNetConnection* GetNetConnection() const override;
	ENGINE_API virtual bool DestroyNetworkActorHandled() override;
	ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
	ENGINE_API virtual void PostInitializeComponents() override;
	ENGINE_API virtual void EnableInput(class APlayerController* PlayerController) override;
	ENGINE_API virtual void DisableInput(class APlayerController* PlayerController) override;
protected:
	ENGINE_API virtual void BeginPlay() override;
	//~ End AActor Interface

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/GameFramework/PlayerInput.h:640

Scope: file

Source code excerpt:

	 *
	 * @param Canvas - Canvas to draw on
	 * @param DebugDisplay - Contains information about what debug data to display
	 * @param YL - Height of the current font
	 * @param YPos - Y position on Canvas. YPos += YL, gives position to draw text for next debug line.
	 */
	ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);

	/** @return key state of the InKey */
	FKeyState* GetKeyState(FKey InKey) { return KeyStateMap.Find(InKey); }
	const FKeyState* GetKeyState(FKey InKey) const { return KeyStateMap.Find(InKey); }

	/** @return true if InKey is currently held */
	ENGINE_API bool IsPressed( FKey InKey ) const;
	
	/** @return true if InKey went from up to down since player input was last processed. */

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Actor.cpp:3037

Scope (from outer to inner):

file
function     void AActor::DisplayDebug

Source code excerpt:

}

void AActor::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
	DisplayDebugManager.SetDrawColor(FColor(255, 0, 0));

	FString T = GetHumanReadableName();
	if( !IsValidChecked(this) )

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Actor.cpp:3054

Scope (from outer to inner):

file
function     void AActor::DisplayDebug

Source code excerpt:

	DisplayDebugManager.SetDrawColor(FColor(255, 255, 255));

	if( DebugDisplay.IsDisplayOn(TEXT("net")) )
	{
		if( GetNetMode() != NM_Standalone )
		{
			// networking attributes
			T = FString::Printf(TEXT("ROLE: %i RemoteRole: %i NetNode: %i"), (int32)GetLocalRole(), (int32)RemoteRole, (int32)GetNetMode());

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Actor.cpp:3071

Scope (from outer to inner):

file
function     void AActor::DisplayDebug

Source code excerpt:

	DisplayDebugManager.DrawString(FString::Printf(TEXT("Location: %s Rotation: %s"), *GetActorLocation().ToCompactString(), *GetActorRotation().ToCompactString()));

	if( DebugDisplay.IsDisplayOn(TEXT("physics")) )
	{
		DisplayDebugManager.DrawString(FString::Printf(TEXT("Velocity: %s Speed: %f Speed2D: %f"), *GetVelocity().ToCompactString(), GetVelocity().Size(), GetVelocity().Size2D()));
	}

	if( DebugDisplay.IsDisplayOn(TEXT("collision")) )
	{
		Canvas->DrawColor.B = 0;
		float MyRadius, MyHeight;
		GetComponentsBoundingCylinder(MyRadius, MyHeight);
		DisplayDebugManager.DrawString(FString::Printf(TEXT("Collision Radius: %f Height: %f"), MyRadius, MyHeight));

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Actor.cpp:3113

Scope (from outer to inner):

file
function     void AActor::DisplayDebug

Source code excerpt:

	static FName NAME_Animation(TEXT("Animation"));
	static FName NAME_Bones = FName(TEXT("Bones"));
	if (DebugDisplay.IsDisplayOn(NAME_Animation) || DebugDisplay.IsDisplayOn(NAME_Bones))
	{
		if (DebugDisplay.IsDisplayOn(NAME_Animation))
		{
			for (UActorComponent* Comp : GetComponents())
			{
				if (USkeletalMeshComponent* SkelMeshComp = Cast<USkeletalMeshComponent>(Comp))
				{
					if (UAnimInstance* AnimInstance = SkelMeshComp->GetAnimInstance())
					{
						AnimInstance->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
					}
				}
			}
		}
	}
}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimInstance.cpp:1043

Scope (from outer to inner):

file
function     void UAnimInstance::DisplayDebug

Source code excerpt:

}

void UAnimInstance::DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
#if ENABLE_DRAW_DEBUG
	FAnimInstanceProxy& Proxy = GetProxyOnGameThread<FAnimInstanceProxy>();

	float Indent = 0.f;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimInstance.cpp:1068

Scope (from outer to inner):

file
function     void UAnimInstance::DisplayDebug

Source code excerpt:

	static FName CAT_FullBlendspaceDisplay(TEXT("FullBlendspaceDisplay"));

	const bool bShowSyncGroups = DebugDisplay.IsCategoryToggledOn(CAT_SyncGroups, true);
	const bool bShowMontages = DebugDisplay.IsCategoryToggledOn(CAT_Montages, true);
	const bool bShowGraph = DebugDisplay.IsCategoryToggledOn(CAT_Graph, true);
	const bool bShowCurves = DebugDisplay.IsCategoryToggledOn(CAT_Curves, true);
	const bool bShowNotifies = DebugDisplay.IsCategoryToggledOn(CAT_Notifies, true);
	const bool bFullGraph = DebugDisplay.IsCategoryToggledOn(CAT_FullAnimGraph, false);
	const bool bFullBlendspaceDisplay = DebugDisplay.IsCategoryToggledOn(CAT_FullBlendspaceDisplay, true);

	FString Heading = FString::Printf(TEXT("Animation: %s"), *GetName());
	DisplayDebugManager.DrawString(Heading, Indent);

	{
		FIndenter CustomDebugIndent(Indent);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/AudioStreamingCache.cpp:2043

Scope (from outer to inner):

file
function     int32 FCachedAudioStreamingManager::RenderStatAudioStreaming

Source code excerpt:

		Y += 12;

		TPair<int, int> Size = Cache.DebugDisplay(World, Viewport, Canvas, X, Y, ViewLocation, ViewRotation);

		// Separate caches are laid out horizontally across the screen, so the total height is equal to our tallest cache panel:
		X += Size.Key;
		Height = FMath::Max(Height, Size.Value);
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/AudioStreamingCache.cpp:2403

Scope (from outer to inner):

file
function     TPair<int, int> FAudioChunkCache::DebugDisplay

Source code excerpt:



TPair<int, int> FAudioChunkCache::DebugDisplay(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation, const FRotator* ViewRotation) const
{
	FScopeLock ScopeLock(const_cast<FCriticalSection*>(&CacheMutationCriticalSection));

	// Draw our header
	const int32 InitialX = X;
	const int32 InitialY = Y;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Camera/CameraModifier.cpp:175

Scope (from outer to inner):

file
function     void UCameraModifier::DisplayDebug

Source code excerpt:

}

void UCameraModifier::DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{

}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Camera/CameraModifier_CameraShake.cpp:488

Scope (from outer to inner):

file
function     void UCameraModifier_CameraShake::DisplayDebug

Source code excerpt:

}

void UCameraModifier_CameraShake::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	Canvas->SetDrawColor(FColor::Yellow);
	UFont* DrawFont = GEngine->GetSmallFont();

	int Indentation = 1;
	int LineNumber = FMath::CeilToInt(YPos / YL);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Camera/CameraModifier_CameraShake.cpp:517

Scope (from outer to inner):

file
function     void UCameraModifier_CameraShake::DisplayDebug

Source code excerpt:


#if UE_ENABLE_DEBUG_DRAWING
	DisplayDebugGraphs(Canvas, DebugDisplay);
#endif

	Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);
}

#if UE_ENABLE_DEBUG_DRAWING

void UCameraModifier_CameraShake::AddCameraShakeDebugData(FActiveCameraShakeInfo& ShakeInfo)
{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Camera/CameraModifier_CameraShake.cpp:565

Scope (from outer to inner):

file
function     void UCameraModifier_CameraShake::DisplayDebugGraphs

Source code excerpt:

}

void UCameraModifier_CameraShake::DisplayDebugGraphs(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay)
{
	const bool bPreviousRecordDebugData = bRecordDebugData;

	// See if we should be recording and display shake data.
	const bool bShowLocationDebug = GShowCameraShakeDebugCVar.GetValueOnGameThread() && 
		GShowCameraShakeDebugLocationCVar.GetValueOnGameThread();

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Character.cpp:997

Scope (from outer to inner):

file
function     void ACharacter::DisplayDebug

Source code excerpt:

}

void ACharacter::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);

	float Indent = 0.f;

	static FName NAME_Physics = FName(TEXT("Physics"));
	if (DebugDisplay.IsDisplayOn(NAME_Physics) )
	{
		FIndenter PhysicsIndent(Indent);

		FString BaseString;
		if ( CharacterMovement == nullptr || BasedMovement.MovementBase == nullptr )
		{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Character.cpp:1024

Scope (from outer to inner):

file
function     void ACharacter::DisplayDebug

Source code excerpt:

		if ( CharacterMovement != nullptr )
		{
			CharacterMovement->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
		}
		const bool Crouched = CharacterMovement && CharacterMovement->IsCrouching();
		FString T = FString::Printf(TEXT("Crouched %i"), Crouched);
		DisplayDebugManager.DrawString(T, Indent);
	}
}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Components/CharacterMovementComponent.cpp:7572

Scope (from outer to inner):

file
function     void UCharacterMovementComponent::DisplayDebug

Source code excerpt:

}

void UCharacterMovementComponent::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	if ( CharacterOwner == NULL )
	{
		return;
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Controller.cpp:650

Scope (from outer to inner):

file
function     void AController::DisplayDebug

Source code excerpt:



void AController::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
	if ( Pawn == NULL )
	{
		if (PlayerState == NULL)
		{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Controller.cpp:661

Scope (from outer to inner):

file
function     void AController::DisplayDebug

Source code excerpt:

		else
		{
			PlayerState->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
		}
		Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);
		return;
	}

	DisplayDebugManager.SetDrawColor(FColor(255, 0, 0));
	DisplayDebugManager.DrawString(FString::Printf(TEXT("CONTROLLER %s Pawn %s"), *GetName(), *Pawn->GetName()));
}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/HUD.cpp:366

Scope (from outer to inner):

file
function     void AHUD::ShowDebug

Source code excerpt:

	else if (DebugType == ShowDebugNames::Reset)
	{
		DebugDisplay.Reset();
		bShowDebugInfo = false;
		SaveConfig();
	}
	else
	{
		bool bRemoved = false;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/HUD.cpp:376

Scope (from outer to inner):

file
function     void AHUD::ShowDebug

Source code excerpt:

		{
			// remove debugtype if already in array
			if (0 != DebugDisplay.Remove(DebugType))
			{
				bRemoved = true;
			}
		}
		if (!bRemoved)
		{
			DebugDisplay.Add(DebugType);
		}

		bShowDebugInfo = true;
		SaveConfig();
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/HUD.cpp:422

Scope (from outer to inner):

file
function     bool AHUD::ShouldDisplayDebug

Source code excerpt:

bool AHUD::ShouldDisplayDebug(const FName& DebugType) const
{
	return bShowDebugInfo && DebugDisplay.Contains(DebugType);
}

void AHUD::ShowDebugInfo(float& YL, float& YPos)
{
	if (DebugCanvas != nullptr && DebugCanvas->Canvas != nullptr)
	{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Pawn.cpp:911

Scope (from outer to inner):

file
function     void APawn::DisplayDebug

Source code excerpt:



void APawn::DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
// 	for (FTouchingComponentsMap::TIterator It(TouchingComponents); It; ++It)
// 	{
// 		UPrimitiveComponent* const MyComp = It.Key().Get();
// 		UPrimitiveComponent* const OtherComp = It.Value().Get();
// 		AActor* OtherActor = OtherComp ? OtherComp->GetOwner() : nullptr;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Pawn.cpp:931

Scope (from outer to inner):

file
function     void APawn::DisplayDebug

Source code excerpt:

	else
	{
		PlayerState->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
	}

	Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);

	DisplayDebugManager.SetDrawColor(FColor(255,255,255));

	if (DebugDisplay.IsDisplayOn(NAME_Camera))
	{
		DisplayDebugManager.DrawString(FString::Printf(TEXT("BaseEyeHeight %f"), BaseEyeHeight));
	}

	// Controller
	if ( Controller == nullptr )

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Pawn.cpp:951

Scope (from outer to inner):

file
function     void APawn::DisplayDebug

Source code excerpt:

	else
	{
		Controller->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
	}
}


void APawn::GetActorEyesViewPoint( FVector& out_Location, FRotator& out_Rotation ) const
{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PlayerCameraManager.cpp:1076

Scope (from outer to inner):

file
function     void APlayerCameraManager::DisplayDebug

Source code excerpt:

}

void APlayerCameraManager::DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	const FMinimalViewInfo& CurrentPOV = GetCameraCacheView();

	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
	DisplayDebugManager.SetDrawColor(FColor(255, 255, 255));
	DisplayDebugManager.DrawString(FString::Printf(TEXT("   Camera Style:%s main ViewTarget:%s"), *CameraStyle.ToString(), *ViewTarget.Target->GetName()));

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PlayerCameraManager.cpp:1096

Scope (from outer to inner):

file
function     void APlayerCameraManager::DisplayDebug

Source code excerpt:

	for (UCameraModifier* Modifier : ModifierList)
	{
		Modifier->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
	}
}

void APlayerCameraManager::ApplyWorldOffset(const FVector& InOffset, bool bWorldShift)
{
	Super::ApplyWorldOffset(InOffset, bWorldShift);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PlayerController.cpp:3326

Scope (from outer to inner):

file
function     void APlayerController::DisplayDebug

Source code excerpt:

/// @endcond

void APlayerController::DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);

	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
	DisplayDebugManager.SetDrawColor(FColor(255, 255, 0));
	DisplayDebugManager.DrawString(FString::Printf(TEXT("STATE %s"), *GetStateName().ToString()));

	if (DebugDisplay.IsDisplayOn(NAME_Camera))
	{
		if (PlayerCameraManager != nullptr)
		{
			DisplayDebugManager.DrawString(FString(TEXT("<<<< CAMERA >>>>")));
			PlayerCameraManager->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
		}
		else
		{
			DisplayDebugManager.SetDrawColor(FColor::Red);
			DisplayDebugManager.DrawString(FString(TEXT("<<<< NO CAMERA >>>>")));
		}
	}
	if ( DebugDisplay.IsDisplayOn(NAME_Input) )
	{
		TArray<UInputComponent*> InputStack;
		BuildInputStack(InputStack);

		DisplayDebugManager.SetDrawColor(FColor::White);
		DisplayDebugManager.DrawString(FString(TEXT("<<<< INPUT STACK >>>")));

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PlayerController.cpp:3371

Scope (from outer to inner):

file
function     void APlayerController::DisplayDebug

Source code excerpt:

		if (PlayerInput)
		{
			PlayerInput->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
		}
		else
		{
			DisplayDebugManager.SetDrawColor(FColor::Red);
			DisplayDebugManager.DrawString(FString(TEXT("NO INPUT")));
		}
	}
	if ( DebugDisplay.IsDisplayOn("ForceFeedback"))
	{
		DisplayDebugManager.SetDrawColor(FColor::White);
		DisplayDebugManager.DrawString(FString::Printf(TEXT("Force Feedback - Enabled: %s LL: %.2f LS: %.2f RL: %.2f RS: %.2f"), (bForceFeedbackEnabled ? TEXT("true") : TEXT("false")), ForceFeedbackValues.LeftLarge, ForceFeedbackValues.LeftSmall, ForceFeedbackValues.RightLarge, ForceFeedbackValues.RightSmall));
		DisplayDebugManager.DrawString(FString::Printf(TEXT("Pawn: %s"), this->AcknowledgedPawn ? *this->AcknowledgedPawn->GetFName().ToString() : TEXT("none")));
		
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/UserInterface/PlayerInput.cpp:1676

Scope (from outer to inner):

file
function     void UPlayerInput::DisplayDebug

Source code excerpt:

}

void UPlayerInput::DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	if (Canvas)
	{
		FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;

#if UE_ENABLE_DEBUG_DRAWING

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/AudioStreamingCache.h:202

Scope (from outer to inner):

file
class        class FAudioChunkCache

Source code excerpt:

	};

	TPair<int, int> DebugDisplay(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation, const FRotator* ViewRotation) const;
	TPair<int, int> DebugVisualDisplay(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation, const FRotator* ViewRotation) const;
	TPair<int, int> DebugBirdsEyeDisplay(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation, const FRotator* ViewRotation) const;

	void IncrementCacheOverflowCounter()
	{
		CacheOverflowCount.Increment();

#Loc: <Workspace>/Engine/Source/Runtime/EngineSettings/Classes/HudSettings.h:20

Scope (from outer to inner):

file
class        class UHudSettings : public UObject

Source code excerpt:

	/** Collection of names specifying what debug info to display for ViewTarget actor.	 */
	UPROPERTY(globalconfig, EditAnywhere, Category=HudSettings)
	TArray<FName> DebugDisplay;
};

#Loc: <Workspace>/Projects/Lyra/Source/LyraGame/Camera/LyraPlayerCameraManager.cpp:44

Scope (from outer to inner):

file
function     void ALyraPlayerCameraManager::DisplayDebug

Source code excerpt:

}

void ALyraPlayerCameraManager::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
{
	check(Canvas);

	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;

	DisplayDebugManager.SetFont(GEngine->GetSmallFont());

#Loc: <Workspace>/Projects/Lyra/Source/LyraGame/Camera/LyraPlayerCameraManager.cpp:54

Scope (from outer to inner):

file
function     void ALyraPlayerCameraManager::DisplayDebug

Source code excerpt:

	DisplayDebugManager.DrawString(FString::Printf(TEXT("LyraPlayerCameraManager: %s"), *GetNameSafe(this)));

	Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);

	const APawn* Pawn = (PCOwner ? PCOwner->GetPawn() : nullptr);

	if (const ULyraCameraComponent* CameraComponent = ULyraCameraComponent::FindCameraComponent(Pawn))
	{
		CameraComponent->DrawDebug(Canvas);

#Loc: <Workspace>/Projects/Lyra/Source/LyraGame/Camera/LyraPlayerCameraManager.h:37

Scope (from outer to inner):

file
class        class ALyraPlayerCameraManager : public APlayerCameraManager

Source code excerpt:

	virtual void UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime) override;

	virtual void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;

private:
	/** The UI Camera Component, controls the camera when UI is doing something important that gameplay doesn't get priority over. */
	UPROPERTY(Transient)
	TObjectPtr<ULyraUICameraManagerComponent> UICamera;
};

#Loc: <Workspace>/Projects/Lyra/Source/LyraGame/Player/LyraCheatManager.cpp:220

Scope (from outer to inner):

file
function     void ULyraCheatManager::CycleAbilitySystemDebug

Source code excerpt:

	if (PC && PC->MyHUD)
	{
		if (!PC->MyHUD->bShowDebugInfo || !PC->MyHUD->DebugDisplay.Contains(TEXT("AbilitySystem")))
		{
			PC->MyHUD->ShowDebug(TEXT("AbilitySystem"));
		}

		PC->ConsoleCommand(TEXT("AbilitySystem.Debug.NextCategory"));
	}