GPUSkinCacheVisualizationIncludedColor

GPUSkinCacheVisualizationIncludedColor

#Overview

name: GPUSkinCacheVisualizationIncludedColor

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 3 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of GPUSkinCacheVisualizationIncludedColor is to define the visualization color for skeletal meshes that are using the GPU skin cache feature in Unreal Engine 5. This variable is part of the rendering system, specifically related to the GPU-based skin cache visualization.

This setting variable is primarily used within the Engine module, particularly in the GPU skin cache subsystem. It’s referenced in the UEngine class definition and utilized in the FGPUSkinCache class for visualization purposes.

The value of this variable is set through the engine configuration system, as indicated by the UPROPERTY(globalconfig) attribute in the UEngine class definition. This means it can be modified in the engine’s configuration files or through project settings.

GPUSkinCacheVisualizationIncludedColor interacts with other related variables such as GPUSkinCacheVisualizationExcludedColor and GPUSkinCacheVisualizationRecomputeTangentsColor. These variables work together to provide different colors for various states of skeletal mesh rendering in the GPU skin cache visualization system.

Developers should be aware that this variable is used for debugging and visualization purposes. It helps in identifying which skeletal meshes are utilizing the GPU skin cache feature when the appropriate visualization mode is enabled.

Best practices when using this variable include:

1. Choosing a distinct color that contrasts well with other visualization colors to easily identify included meshes.
2. Considering color-blind friendly options if accessibility is a concern.
3. Using this variable in conjunction with other GPU skin cache visualization settings for comprehensive debugging.
4. Remembering that changing this color only affects the visualization and does not impact the actual rendering performance or quality of the skeletal meshes.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEngine.ini:264, section: [/Script/Engine.Engine]

• INI Section: /Script/Engine.Engine
• Raw value: (R=0.0,G=1.0,B=0.0,A=1.0) ; green (use skin cache on sk mesh)
• Is Array: False

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Engine/Engine.h:1224

Scope (from outer to inner):

file
class        class UEngine : public UObject , public FExec

Source code excerpt:

	/** The visualization color when sk mesh using skin cache. */
	UPROPERTY(globalconfig)
	FLinearColor GPUSkinCacheVisualizationIncludedColor;

	/** The visualization color when sk mesh using recompute tangents. */
	UPROPERTY(globalconfig)
	FLinearColor GPUSkinCacheVisualizationRecomputeTangentsColor;

	/** The memory visualization threshold in MB for a skin cache entry */

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinCache.cpp:2459

Scope (from outer to inner):

file
function     FColor FGPUSkinCache::GetVisualizationDebugColor

Source code excerpt:

			bool bRecomputeTangent = Entry && Entry->DispatchData[SectionIndex].IndexBuffer;
			return Entry ? 
				   (bRecomputeTangent ? GEngine->GPUSkinCacheVisualizationRecomputeTangentsColor.QuantizeRound() : GEngine->GPUSkinCacheVisualizationIncludedColor.QuantizeRound()) : 
				   GEngine->GPUSkinCacheVisualizationExcludedColor.QuantizeRound();
		}
		else if (ModeType == FGPUSkinCacheVisualizationData::FModeType::Memory)
		{
			uint64 MemoryInBytes = (Entry && Entry->PositionAllocation) ? Entry->PositionAllocation->GetNumBytes() : 0;
#if RHI_RAYTRACING

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinCache.cpp:2513

Scope (from outer to inner):

file
function     void FGPUSkinCache::DrawVisualizationInfoText

Source code excerpt:

			DrawText(TEXT("Non SK mesh"), FColor::White);
			DrawText(TEXT("SK Skin Cache Excluded"), GEngine->GPUSkinCacheVisualizationExcludedColor.QuantizeRound());
			DrawText(TEXT("SK Skin Cache Included"), GEngine->GPUSkinCacheVisualizationIncludedColor.QuantizeRound());
			DrawText(TEXT("SK Recompute Tangent ON"), GEngine->GPUSkinCacheVisualizationRecomputeTangentsColor.QuantizeRound());
		}
		else if (ModeType == FGPUSkinCacheVisualizationData::FModeType::Memory)
		{
			float UsedMemoryInMB = UsedMemoryInBytes / MBSize;
			float AvailableMemoryInMB = GSkinCacheSceneMemoryLimitInMB - UsedMemoryInMB;