SlateBrush.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Styling/SlateColor.h"
#include "Layout/Margin.h"
#include "Rendering/SlateResourceHandle.h"
#include "Types/SlateBox2.h"
#include "Types/SlateVector2.h"
#include "SlateBrush.generated.h"
 
UENUM(BlueprintType)
namespace ESlateBrushDrawType
{
    enum Type : int
    {
        NoDrawType UMETA(DisplayName="None"),
 
        Box,
 
        Border,
 
        Image,
 
        RoundedBox
    };
}
 
 
UENUM(BlueprintType)
namespace ESlateBrushTileType
{
    enum Type : int
    {
        NoTile,
 
        Horizontal,
 
        Vertical,
 
        Both
    };
}
 
 
UENUM()
namespace ESlateBrushMirrorType
{
    enum Type : int
    {
        NoMirror,
 
        Horizontal,
 
        Vertical,
 
        Both
    };
}
 
 
UENUM()
namespace ESlateBrushImageType
{
    enum Type : int
    {
        NoImage,
 
        FullColor,
 
        Linear,
 
        Vector,
    };
}
 
 
UENUM()
namespace ESlateBrushRoundingType
{
    enum Type : int
    {
        FixedRadius, 
 
        HalfHeightRadius,
    };
}
 
 
USTRUCT(BlueprintType)
struct FSlateBrushOutlineSettings
{
    GENERATED_USTRUCT_BODY()
 
    FSlateBrushOutlineSettings()
        : CornerRadii(FVector4(0.0, 0.0, 0.0, 0.0))
        , Color(FLinearColor::Transparent)
        , Width(0.0)
        , RoundingType(ESlateBrushRoundingType::HalfHeightRadius)
        , bUseBrushTransparency(false)
    {}
 
    FSlateBrushOutlineSettings(float InUniformRadius)
        : CornerRadii(FVector4(InUniformRadius, InUniformRadius, InUniformRadius, InUniformRadius))
        , Color(FLinearColor::Transparent)
        , Width(0.0)
        , RoundingType(ESlateBrushRoundingType::FixedRadius)
        , bUseBrushTransparency(false)
    {}
 
    FSlateBrushOutlineSettings(FVector4 InRadius)
        : CornerRadii(InRadius)
        , Color(FLinearColor::Transparent)
        , Width(0.0)
        , RoundingType(ESlateBrushRoundingType::FixedRadius)
        , bUseBrushTransparency(false)
    {}
 
    FSlateBrushOutlineSettings(const FSlateColor& InColor, float InWidth)
        : CornerRadii(FVector4(0.0, 0.0, 0.0, 0.0))
        , Color(InColor)
        , Width(InWidth)
        , RoundingType(ESlateBrushRoundingType::HalfHeightRadius)
        , bUseBrushTransparency(false)
    {}
 
    FSlateBrushOutlineSettings(float InUniformRadius, const FSlateColor& InColor, float InWidth)
        : CornerRadii(FVector4(InUniformRadius, InUniformRadius, InUniformRadius, InUniformRadius))
        , Color(InColor)
        , Width(InWidth)
        , RoundingType(ESlateBrushRoundingType::FixedRadius)
        , bUseBrushTransparency(false)
    {}
 
    FSlateBrushOutlineSettings(FVector4 InRadius, const FSlateColor& InColor, float InWidth)
        : CornerRadii(InRadius)
        , Color(InColor)
        , Width(InWidth)
        , RoundingType(ESlateBrushRoundingType::FixedRadius)
        , bUseBrushTransparency(false)
    {}
 
    bool operator==(const FSlateBrushOutlineSettings& Other) const
    {
        return CornerRadii == Other.CornerRadii
            && Color == Other.Color
            && Width == Other.Width
            && RoundingType == Other.RoundingType
            && bUseBrushTransparency == Other.bUseBrushTransparency;
    }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush)
    FVector4 CornerRadii;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush, meta=(DisplayName="Outline", sRGB="true"))
    FSlateColor Color;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush)
    float Width;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush)
    TEnumAsByte<enum ESlateBrushRoundingType::Type > RoundingType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush)
    bool bUseBrushTransparency;
 
};
 
namespace SlateBrushDefs
{
    inline constexpr float DefaultImageSize = 32.0f;
}
 
// Hacky base class to avoid 8 bytes of padding after the vtable
struct FSlateBrushFixLayout
{
    virtual ~FSlateBrushFixLayout() = default;
};
 
USTRUCT(BlueprintType) //, meta = (HasNativeMake = ""))
struct FSlateBrush 
#if CPP 
: public FSlateBrushFixLayout
#endif
{
    GENERATED_USTRUCT_BODY()
 
    friend class FSlateShaderResourceManager;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush, meta=( DisplayName="Tint", sRGB="true" ))
    FSlateColor TintColor;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush)
    TEnumAsByte<enum ESlateBrushDrawType::Type > DrawAs;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush)
    TEnumAsByte<enum ESlateBrushTileType::Type> Tiling;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush)
    TEnumAsByte<enum ESlateBrushMirrorType::Type> Mirroring;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Brush)
    TEnumAsByte<enum ESlateBrushImageType::Type> ImageType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush)
    FDeprecateSlateVector2D ImageSize;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush, meta=( UVSpace="true" ))
    FMargin Margin;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(NotReplicated)
    FLinearColor Tint_DEPRECATED;
#endif
 
public:
 
    SLATECORE_API FSlateBrush();
 
    virtual ~FSlateBrush(){}
 
public:
 
    UE::Slate::FDeprecateVector2DResult GetImageSize() const { return UE::Slate::FDeprecateVector2DResult(ImageSize); }
    void SetImageSize(UE::Slate::FDeprecateVector2DParameter InImageSize) { ImageSize = InImageSize; }
 
    const FMargin& GetMargin() const { return Margin; }
 
    ESlateBrushTileType::Type GetTiling() const { return Tiling; }
 
    ESlateBrushMirrorType::Type GetMirroring() const { return Mirroring; }
 
    ESlateBrushImageType::Type GetImageType() const { return ImageType; }
 
    ESlateBrushDrawType::Type GetDrawType() const { return DrawAs; }
 
    const FName GetResourceName() const
    {
        return ( ( ResourceName != NAME_None ) || ( ResourceObject == nullptr ) )
            ? ResourceName
            : ResourceObject->GetFName();
    }
 
    class UObject* GetResourceObject( ) const
    {
        return ResourceObject;
    }
 
    SLATECORE_API void SetResourceObject(class UObject* InResourceObject);
 
    FLinearColor GetTint( const FWidgetStyle& InWidgetStyle ) const
    {
        return TintColor.GetColor(InWidgetStyle);
    }
 
    void UnlinkColors()
    {
        TintColor.Unlink();
    }
 
    bool HasUObject( ) const
    {
        return (ResourceObject != nullptr) || (bHasUObject_DEPRECATED);
    }
 
    bool IsDynamicallyLoaded( ) const
    {
        return bIsDynamicallyLoaded;
    }
 
    UE::Slate::FDeprecateBox2D GetUVRegion() const
    {
        return UVRegion;
    }
 
    void SetUVRegion(const FBox2d& InUVRegion)
    {
        UVRegion = FBox2f(InUVRegion);
    }
 
    void SetUVRegion(const FBox2f& InUVRegion)
    {
        UVRegion = InUVRegion;
    }
 
    bool operator==( const FSlateBrush& Other ) const 
    {
        return ImageSize == Other.ImageSize
            && DrawAs == Other.DrawAs
            && Margin == Other.Margin
            && TintColor == Other.TintColor
            && Tiling == Other.Tiling
            && Mirroring == Other.Mirroring
            && ResourceObject == Other.ResourceObject
            && ResourceName == Other.ResourceName
            && bIsDynamicallyLoaded == Other.bIsDynamicallyLoaded
            && UVRegion == Other.UVRegion
            && (DrawAs != ESlateBrushDrawType::RoundedBox || OutlineSettings == Other.OutlineSettings); // Compare outline settings for equality only if we have a rounded box brush.
    }
 
    bool operator!=( const FSlateBrush& Other ) const 
    {
        return !(*this == Other);
    }
 
    void AddReferencedObjects(FReferenceCollector& Collector, UObject* ReferencingObject = nullptr)
    {
        Collector.AddReferencedObject(ResourceObject, ReferencingObject);
    }
 
    static SLATECORE_API const FString UTextureIdentifier( );
    
    const FSlateResourceHandle& GetRenderingResource(UE::Slate::FDeprecateVector2DParameter LocalSize, float DrawScale) const
    {
        UpdateRenderingResource(LocalSize, DrawScale);
 
        return ResourceHandle;
    }
 
    SLATECORE_API const FSlateResourceHandle& GetRenderingResource() const;
 
    bool IsSet() const { return bIsSet; }
 
#if WITH_EDITOR
    void InvalidateResourceHandle()
    {
        ResourceHandle = FSlateResourceHandle();
    };
#endif
 
private:
    SLATECORE_API void UpdateRenderingResource(FVector2f LocalSize, float DrawScale) const;
    SLATECORE_API bool CanRenderResourceObject(UObject* InResourceObject) const;
 
private:
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush, meta=( AllowPrivateAccess="true", DisplayThumbnail="true", DisplayName="Image", AllowedClasses="/Script/Engine.Texture,/Script/Engine.MaterialInterface,/Script/Engine.SlateTextureAtlasInterface", DisallowedClasses = "/Script/MediaAssets.MediaTexture"))
    TObjectPtr<UObject> ResourceObject;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Brush)
    FSlateBrushOutlineSettings OutlineSettings;
 
protected:
    UPROPERTY()
    FBox2f UVRegion;
 
    UPROPERTY()
    uint8 bIsDynamicallyLoaded:1;
 
    UPROPERTY()
    uint8 bHasUObject_DEPRECATED:1;
 
    uint8 bIsSet : 1;
 
public:
 
    mutable FSlateResourceHandle ResourceHandle;
 
protected:
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Brush)
    FName ResourceName;
 
     SLATECORE_API FORCENOINLINE FSlateBrush( ESlateBrushDrawType::Type InDrawType, const FName InResourceName, const FMargin& InMargin, ESlateBrushTileType::Type InTiling, ESlateBrushImageType::Type InImageType, const UE::Slate::FDeprecateVector2DParameter& InImageSize, const FLinearColor& InTint = FLinearColor::White, UObject* InObjectResource = nullptr, bool bInDynamicallyLoaded = false);
 
     SLATECORE_API FORCENOINLINE FSlateBrush( ESlateBrushDrawType::Type InDrawType, const FName InResourceName, const FMargin& InMargin, ESlateBrushTileType::Type InTiling, ESlateBrushImageType::Type InImageType, const UE::Slate::FDeprecateVector2DParameter& InImageSize, const TSharedRef< FLinearColor >& InTint, UObject* InObjectResource = nullptr, bool bInDynamicallyLoaded = false);
 
     SLATECORE_API FORCENOINLINE FSlateBrush( ESlateBrushDrawType::Type InDrawType, const FName InResourceName, const FMargin& InMargin, ESlateBrushTileType::Type InTiling, ESlateBrushImageType::Type InImageType, const UE::Slate::FDeprecateVector2DParameter& InImageSize, const FSlateColor& InTint, UObject* InObjectResource = nullptr, bool bInDynamicallyLoaded = false);
 
};
 
class ISlateBrushSource
{
public:
    virtual ~ISlateBrushSource() = default;
    virtual const FSlateBrush* GetSlateBrush() const = 0;
};