UColorUtilities Class Reference

#include <ColorUtilities.h>

Inheritance diagram for UColorUtilities:

Collaboration diagram for UColorUtilities:

Static Public Member Functions
static FLinearColor	HexToLinearColor (const FString &HexString, bool &bSuccess)
	Converts a hex color code (e.g. "#FF00FF" or "#FF00FFAA" or "FF00FF" or "FF00FFAA) to an FLinearColor. More...
static FLinearColor	RGBStringToLinearColor (const FString &ColorString, bool &bSuccess)
	Converts a comma-separated color string ("r,g,b" or "r,g,b,a") to an FLinearColor. More...
static FLinearColor	AutoDetectColorStringToLinearColor (const FString &ColorString, bool &bSuccess)
	Tries to auto detect format for color string, and convert it to linear color accordingly. More...
static FString	LinearColorToHex (const FLinearColor &Color, bool bIncludeAlpha, bool bAddPrefix)
static FString	LinearColorToRGBString (const FLinearColor &Color, bool bIncludeAlpha)
static bool	IsValidRGBString (const FString &ColorString)
static bool	IsValidHexString (const FString &ColorString)

Detailed Description

Color utilities is a Blueprint Function Library for converting colors from string and back.

Definition at line 18 of file ColorUtilities.h.

Member Function Documentation

AutoDetectColorStringToLinearColor()

FLinearColor UColorUtilities::AutoDetectColorStringToLinearColor ( const FString &  ColorString, bool &  bSuccess  )

static

Tries to auto detect format for color string, and convert it to linear color accordingly.

Parameters

ColorString
bSuccess	Was the conversion success (was the format correct)

Returns

Definition at line 177 of file ColorUtilities.cpp.

{
    FString TrimmedString = ColorString.TrimStartAndEnd(); // Remove leading/trailing spaces
    FLinearColor ConvertedColor;
 
    // First try to convert string to linear color assuming it's rgb
    ConvertedColor = RGBStringToLinearColor(TrimmedString, bSuccess);
 
    // If that fails, assume it's hex
    if (!bSuccess)
    {
        ConvertedColor = HexToLinearColor(TrimmedString, bSuccess);
    }
 
    // return converted color (and bSuccess). ConvertedColor set to FLinearColor::White if conversion failed in previous steps
    return ConvertedColor;
}

References HexToLinearColor(), and RGBStringToLinearColor().

HexToLinearColor()

FLinearColor UColorUtilities::HexToLinearColor ( const FString &  HexString, bool &  bSuccess  )

static

Converts a hex color code (e.g. "#FF00FF" or "#FF00FFAA" or "FF00FF" or "FF00FFAA) to an FLinearColor.

Parameters

HexString
bSuccess	Was the conversion success (was the format correct)

Returns

Definition at line 9 of file ColorUtilities.cpp.

{
 
    if (IsValidHexString(HexString))
    {
        bSuccess = true;
        /*
        Creates a color value from the given hexadecimal string.
        Supported formats are: RGB, RRGGBB, RRGGBBAA, RGB, #RRGGBB, #RRGGBBAA The corresponding color value.
        */
        FColor Color = FColor::FromHex(HexString);
        return Color.ReinterpretAsLinear();
    }
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("Invalid Hex String Format: %s"), *HexString);
        bSuccess = false;
        return FLinearColor::White;
    }
 
    // FString CleanHex = HexString.Replace(TEXT("#"), TEXT("")); // Remove #
 
    // if (CleanHex.Len() != 6 && CleanHex.Len() != 8)
    //{
    //  UE_LOG(LogTemp, Warning, TEXT("Invalid Hex Color Length: %s"), *HexString);
    //  return FLinearColor::White;
    // }
 
    // int32 R, G, B, A = 255; // Default alpha to 255
 
    // FDefaultValueHelper::ParseInt(CleanHex.Mid(0, 2), R, 16);
    // FDefaultValueHelper::ParseInt(CleanHex.Mid(2, 2), G, 16);
    // FDefaultValueHelper::ParseInt(CleanHex.Mid(4, 2), B, 16);
 
    // if (CleanHex.Len() == 8)
    //{
    //  FDefaultValueHelper::ParseInt(CleanHex.Mid(6, 2), A, 16);
    // }
 
    // return FLinearColor(R / 255.0f, G / 255.0f, B / 255.0f, A / 255.0f);
}

References IsValidHexString().

Referenced by AutoDetectColorStringToLinearColor().

IsValidHexString()

bool UColorUtilities::IsValidHexString ( const FString &  ColorString )

static

Checks if a given string is a valid Hex color format (e.g., "#FFAABB" or "FFAABBCC").

Parameters

ColorString

The string to validate.

Returns

true if the string is a valid Hex format, false otherwise.

Definition at line 155 of file ColorUtilities.cpp.

{
    FString TrimmedString = ColorString.TrimStartAndEnd().Replace(TEXT("#"), TEXT("")); // Remove '#' if present
 
    // Must be exactly 6 (RRGGBB) or 8 (RRGGBBAA) characters long, shorthand (RGB) not supported
    if (TrimmedString.Len() != 6 && TrimmedString.Len() != 8)
    {
        return false;
    }
 
    // Ensure all characters are valid hex digits (0-9, A-F, a-f)
    for (TCHAR Char : TrimmedString)
    {
        if (!FChar::IsHexDigit(Char))
        {
            return false;
        }
    }
 
    return true; // Valid hex format
}

Referenced by HexToLinearColor().

IsValidRGBString()

bool UColorUtilities::IsValidRGBString ( const FString &  ColorString )

static

Checks if a given string is a valid RGB(A) color format (e.g., "255,128,64" or "255,128,64,200").

Parameters

ColorString

The string to validate.

Returns

true if the string is a valid RGB(A) format, false otherwise.

Definition at line 131 of file ColorUtilities.cpp.

{
    FString TrimmedString = ColorString.TrimStartAndEnd(); // Remove whitespace
    TArray<FString> Components;
    TrimmedString.ParseIntoArray(Components, TEXT(","), true);
 
    // RGB(A) must have 3 or 4 integer values
    if (Components.Num() < 3 || Components.Num() > 4)
    {
        return false;
    }
 
    for (const FString& Component : Components)
    {
        int32 Value;
        if (!FDefaultValueHelper::ParseInt(Component, Value) || Value < 0 || Value > 255)
        {
            return false; // Must be an integer between 0-255
        }
    }
 
    return true; // Valid RGB or RGBA format
}

Referenced by RGBStringToLinearColor().

LinearColorToHex()

FString UColorUtilities::LinearColorToHex ( const FLinearColor &  Color, bool  bIncludeAlpha, bool  bAddPrefix  )

static

Converts an FLinearColor to a hex string (e.g. "#RRGGBB" or "#RRGGBBAA" if IncludeAlpha is true)

Definition at line 82 of file ColorUtilities.cpp.

{
    FColor ConvertedColor = Color.Quantize();   // Converts FLinearColor to FColor
    FString HexString = ConvertedColor.ToHex(); // Returns RRGGBBAA format
 
    if (!bIncludeAlpha)
    {
        HexString = HexString.Left(6); // Trim the last two characters (AA)
    }
 
    if (bAddPrefix)
    {
        HexString = FString("#") + HexString;
    }
 
    return HexString;
 
    // int32 R = FMath::RoundToInt(Color.R * 255);
    // int32 G = FMath::RoundToInt(Color.G * 255);
    // int32 B = FMath::RoundToInt(Color.B * 255);
    // int32 A = FMath::RoundToInt(Color.A * 255);
 
    // FString HexString = FString::Printf(TEXT("#%02X%02X%02X"), R, G, B);
 
    // if (bIncludeAlpha)
    //{
    //  HexString += FString::Printf(TEXT("%02X"), A);
    // }
 
    // return HexString;
}

LinearColorToRGBString()

FString UColorUtilities::LinearColorToRGBString ( const FLinearColor &  Color, bool  bIncludeAlpha  )

static

Converts an FLinearColor to an "R,G,B" or "R,G,B,A" formatted string

Definition at line 114 of file ColorUtilities.cpp.

{
    int32 R = FMath::RoundToInt(Color.R * 255);
    int32 G = FMath::RoundToInt(Color.G * 255);
    int32 B = FMath::RoundToInt(Color.B * 255);
    int32 A = FMath::RoundToInt(Color.A * 255);
 
    if (bIncludeAlpha)
    {
        return FString::Printf(TEXT("%d,%d,%d,%d"), R, G, B, A);
    }
    else
    {
        return FString::Printf(TEXT("%d,%d,%d"), R, G, B);
    }
}

RGBStringToLinearColor()

FLinearColor UColorUtilities::RGBStringToLinearColor ( const FString &  ColorString, bool &  bSuccess  )

static

Converts a comma-separated color string ("r,g,b" or "r,g,b,a") to an FLinearColor.

Parameters

ColorString
bSuccess	Was the conversion success (was the format correct)

Returns

Definition at line 52 of file ColorUtilities.cpp.

{
    if (IsValidRGBString(ColorString))
    {
        bSuccess = true;
        TArray<FString> Components;
        ColorString.ParseIntoArray(Components, TEXT(","), true);
 
        int32 R = 0, G = 0, B = 0, A = 255; // Default alpha to 255 (fully opaque)
 
        // Parse integer values from the string components
        FDefaultValueHelper::ParseInt(Components[0], R);
        FDefaultValueHelper::ParseInt(Components[1], G);
        FDefaultValueHelper::ParseInt(Components[2], B);
 
        if (Components.Num() == 4) // If alpha is provided
        {
            FDefaultValueHelper::ParseInt(Components[3], A);
        }
 
        // Convert to linear color
        return FLinearColor(R / 255.0f, G / 255.0f, B / 255.0f, A / 255.0f);
    }
 
    // Invalid string format
    bSuccess = false;
    UE_LOG(LogTemp, Warning, TEXT("Invalid Color String Format: %s"), *ColorString);
    return FLinearColor::White;
}

References IsValidRGBString().

Referenced by AutoDetectColorStringToLinearColor().

---

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

• Unreal/Agrarsense/Source/Agrarsense/Utils/ColorUtilities.h
• Unreal/Agrarsense/Source/Agrarsense/Utils/ColorUtilities.cpp