151 lines
7.5 KiB
C++
151 lines
7.5 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
#pragma once
|
|
|
|
#include "2D/Mask/MaskEnums.h"
|
|
#include "CoreMinimal.h"
|
|
#include "Data/RawBuffer.h"
|
|
#include "Engine/TextureRenderTarget2D.h"
|
|
#include "Helper/Promise.h"
|
|
#include "Kismet/KismetRenderingLibrary.h"
|
|
#include "PixelFormat.h"
|
|
#include "TextureContent.h"
|
|
#include "TextureType.h"
|
|
|
|
class Tex;
|
|
class UTextureRenderTarget2D;
|
|
class UTexture2D;
|
|
struct BufferDescriptor;
|
|
enum class ETG_TextureFormat : uint8;
|
|
enum class ETSBufferFormat;
|
|
class TiledBlob;
|
|
typedef std::shared_ptr<TiledBlob> TiledBlobPtr;
|
|
|
|
typedef cti::continuable<bool> AsyncBool;
|
|
typedef cti::continuable<FLinearColor> AsyncLinearColor;
|
|
|
|
struct TEXTUREGRAPHENGINE_API TextureHelper
|
|
{
|
|
static TiledBlobPtr GTransparent; /// Transparent RGBA texture
|
|
static TiledBlobPtr GBlack; /// Black RGBA texture
|
|
static TiledBlobPtr GWhite; /// White RGBA texture
|
|
static TiledBlobPtr GGray; /// Gray RGBA texture
|
|
static TiledBlobPtr GRed; /// Red RGBA texture
|
|
static TiledBlobPtr GGreen; /// Green RGBA texture
|
|
static TiledBlobPtr GBlue; /// Blue RGBA texture
|
|
static TiledBlobPtr GYellow; /// Yellow RGBA texture
|
|
static TiledBlobPtr GMagenta; /// Magenta RGBA texture
|
|
static TiledBlobPtr GDefaultNormal; /// Default Normal RGBA texture
|
|
static TiledBlobPtr GWhiteMask; /// Default white mask
|
|
static TiledBlobPtr GBlackMask; /// Default black mask
|
|
|
|
static cti::continuable<bool> InitSolidTexture(TiledBlobPtr* BlobObj, FLinearColor Color, FString Name, struct TexDescriptor Desc);
|
|
static void InitStockTextures();
|
|
static void FreeStockTextures();
|
|
|
|
static FORCEINLINE TiledBlobPtr GetTransparent() { check(GTransparent); return GTransparent; }
|
|
static FORCEINLINE TiledBlobPtr GetBlack() { check(GBlack); return GBlack; }
|
|
static FORCEINLINE TiledBlobPtr GetWhite() { check(GWhite); return GWhite; }
|
|
static FORCEINLINE TiledBlobPtr GetGray() { check(GGray); return GGray; }
|
|
static FORCEINLINE TiledBlobPtr GetRed() { check(GRed); return GRed; }
|
|
static FORCEINLINE TiledBlobPtr GetGreen() { check(GGreen); return GGreen; }
|
|
static FORCEINLINE TiledBlobPtr GetBlue() { check(GBlue); return GBlue; }
|
|
static FORCEINLINE TiledBlobPtr GetYellow() { check(GYellow); return GYellow; }
|
|
static FORCEINLINE TiledBlobPtr GetMagenta() { check(GMagenta); return GMagenta; }
|
|
static FORCEINLINE TiledBlobPtr GetErrorBlob() { return GetMagenta(); }
|
|
static FORCEINLINE TiledBlobPtr GetDefaultNormal() { check(GDefaultNormal); return GDefaultNormal; }
|
|
static FORCEINLINE TiledBlobPtr GetWhiteMask() { check(GWhiteMask); return GWhiteMask; }
|
|
static FORCEINLINE TiledBlobPtr GetBlackMask() { check(GBlackMask); return GBlackMask; }
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
static uint32 GetChannelsFromPixelFormat(EPixelFormat InPixelFormat);
|
|
static uint32 GetBppFromPixelFormat(EPixelFormat InPixelFormat);
|
|
static ETextureRenderTargetFormat GetRenderTargetFormatFromPixelFormat(EPixelFormat InPixelFormat);
|
|
static ETextureSourceFormat GetSourceFormat(ETG_TextureFormat TGTextureFormat);
|
|
static bool GetBufferFormatAndChannelsFromTGTextureFormat(ETG_TextureFormat Format, BufferFormat& OutBufferFormat, uint32& OutBufferChannels);
|
|
static EPixelFormat GetPixelFormatFromRenderTargetFormat(ETextureRenderTargetFormat RTFormat);
|
|
static bool GetPixelFormatFromTextureSourceFormat(ETextureSourceFormat SourceFormat, EPixelFormat& OutPixelFormat, uint32& OutNumChannels);
|
|
static ETextureSourceFormat GetTextureSourceFormat(BufferFormat Format, uint32 ItemsPerPoint);
|
|
static ETG_TextureFormat GetTGTextureFormatFromChannelsAndFormat(uint32 ItemsPerPoint, BufferFormat Format);
|
|
static uint32 GetNumChannelsFromTGTextureFormat(ETG_TextureFormat TextureFormat);
|
|
static FString GetChannelsTextFromItemsPerPoint(const int32 InItemsPerPoint);
|
|
static void ClearRT(UTextureRenderTarget2D* RenderTarget, FLinearColor Color = FLinearColor::Transparent);
|
|
static void ClearRT(FRHICommandList& RHI, UTextureRenderTarget2D* RenderTarget, FLinearColor Color = FLinearColor::Transparent);
|
|
|
|
static const char* TextureTypeToString(TextureType Type);
|
|
static TextureType TextureStringToType(const FString& TypeString);
|
|
static const char* TextureTypeToMegascansType(TextureType Type);
|
|
|
|
static TextureType TextureContentToTextureType(TextureContent Content);
|
|
static TextureContent TextureTypeToTextureContent(TextureType Type);
|
|
static MaskType TextureContentToMaskType(TextureContent Content);
|
|
static TextureContent MaskTypeToTextureContent(MaskType Type);
|
|
static MaskModifierType TextureContentToMaskModifier(TextureContent Content);
|
|
static TextureContent MaskModifierToTextureContent(MaskModifierType Type);
|
|
|
|
static RawBufferPtr RawFromRT(UTextureRenderTarget2D* RenderTarget, const BufferDescriptor& Desc);
|
|
static RawBufferPtr RawFromTexture(UTexture2D* Texture, const BufferDescriptor& Desc);
|
|
static RawBufferPtr RawFromResource(const FTextureRHIRef& ResourceRHI, const BufferDescriptor& Desc);
|
|
static BufferFormat FindOptimalSupportedFormat(BufferFormat SrcFormat);
|
|
|
|
static void RawFromRT_Tiled(UTextureRenderTarget2D* RenderTarget, const BufferDescriptor& Desc, size_t TileSizeX, size_t TileSizeY, RawBufferPtrTiles& Tiles);
|
|
static void RawFromTexture_Tiled(UTexture2D* Texture, const BufferDescriptor& Desc, size_t TileSizeX, size_t TileSizeY, RawBufferPtrTiles& Tiles);
|
|
static void RawFromResource_Tiled(FTextureRHIRef ResourceRHI, const BufferDescriptor& Desc, size_t TileSizeX, size_t TileSizeY, RawBufferPtrTiles& Tiles);
|
|
static void RawFromMem_Tiled(const uint8* SrcData, size_t SrcDataLength, const BufferDescriptor& SrcDesc, size_t TileSizeX, size_t TileSizeY, RawBufferPtrTiles& Tiles);
|
|
static RawBufferPtr CombineRaw_Tiles(const RawBufferPtrTiles& Tiles, CHashPtr HashValue = nullptr, bool bIsTransient = false);
|
|
|
|
static bool IsFloatRT(UTextureRenderTarget2D* RenderTarget);
|
|
static FLinearColor GetPixelValueFromRaw(RawBufferPtr RawObj, int32 Width, int32 Height, int32 X, int32 Y);
|
|
static AsyncBool ExportRaw(RawBufferPtr RawObj, const FString& CompletePath);
|
|
static bool CanSupportTexture(UTexture* Tex);
|
|
static bool CanSplitToTiles(int Width, int Height, int TilesX, int TilesY);
|
|
static size_t RoundUpTo(size_t Size, size_t DesiredRounding);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Inline functions
|
|
//////////////////////////////////////////////////////////////////////////
|
|
static FORCEINLINE FString CreateTileName(const FString& BaseName, int32 TileX, int32 TileY)
|
|
{
|
|
return FString::Printf(TEXT("%s-%d,%d"), *BaseName, TileX, TileY);
|
|
}
|
|
|
|
template <class T>
|
|
static FORCEINLINE bool IsPowerOf2(T Value)
|
|
{
|
|
return Value > 0 && (Value & (Value - 1)) == 0;
|
|
}
|
|
|
|
template <class T>
|
|
static FORCEINLINE T FloorToPowerOf2(T Value)
|
|
{
|
|
Value = Value | (Value >> 1);
|
|
Value = Value | (Value >> 2);
|
|
Value = Value | (Value >> 4);
|
|
Value = Value | (Value >> 8);
|
|
Value = Value | (Value >> 16);
|
|
return Value - (Value >> 1);;
|
|
}
|
|
|
|
template <class T>
|
|
static FORCEINLINE T CeilToPowerOf2(T Value)
|
|
{
|
|
Value--;
|
|
|
|
Value |= Value >> 1;
|
|
Value |= Value >> 2;
|
|
Value |= Value >> 4;
|
|
Value |= Value >> 8;
|
|
Value |= Value >> 16;
|
|
Value++;
|
|
|
|
return Value;
|
|
}
|
|
|
|
|
|
// Calculate the total number of mip levels for a given base size.
|
|
// This is including the level 0 of said base size
|
|
static FORCEINLINE uint32 CalcNumMipLevels(uint32 BaseSize)
|
|
{
|
|
return (uint32)(ceil(log2(double(BaseSize))) + 1.0);
|
|
}
|
|
};
|