CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Developer/TextureFormatIntelISPCTexComp/Private/TextureFormatIntelISPCTexComp.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

1103 lines
35 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "Containers/SharedString.h"
#include "HAL/FileManager.h"
#include "Misc/CommandLine.h"
#include "Containers/IndirectArray.h"
#include "Stats/Stats.h"
#include "Async/AsyncWork.h"
#include "Misc/ConfigCacheIni.h"
#include "ImageCore.h"
#include "Modules/ModuleManager.h"
#include "Interfaces/ITextureFormat.h"
#include "Interfaces/ITextureFormatModule.h"
#include "TextureCompressorModule.h"
#include "PixelFormat.h"
#include "Async/ParallelFor.h"
#include "Serialization/CompactBinary.h"
#include "Serialization/CompactBinaryWriter.h"
#include "TextureBuildFunction.h"
#include "DerivedDataBuildFunctionFactory.h"
#include "Misc/WildcardString.h"
#include "ispc_texcomp.h"
DEFINE_LOG_CATEGORY_STATIC(LogTextureFormatIntelISPCTexComp, Log, All);
class FIntelISPCTexCompTextureBuildFunction final : public FTextureBuildFunction
{
const UE::FUtf8SharedString& GetName() const final
{
static const UE::FUtf8SharedString Name(UTF8TEXTVIEW("IntelISPCTexCompTexture"));
return Name;
}
void GetVersion(UE::DerivedData::FBuildVersionBuilder& Builder, ITextureFormat*& OutTextureFormatVersioning) const final
{
static FGuid Version(TEXT("19d413ad-f529-4687-902a-3b71919cfd72"));
Builder << Version;
OutTextureFormatVersioning = FModuleManager::GetModuleChecked<ITextureFormatModule>(TEXT("TextureFormatIntelISPCTexComp")).GetTextureFormat();
}
};
// increment this if you change anything that will affect compression in this file
#define BASE_ISPC_DX11_FORMAT_VERSION 9
// For debugging intermediate image results by saving them out as files.
#define DEBUG_SAVE_INTERMEDIATE_IMAGES 0
/**
* Macro trickery for supported format names.
*/
#define ENUM_SUPPORTED_FORMATS(op) \
op(BC6H) \
op(BC7)
#define DECL_FORMAT_NAME(FormatName) static FName GTextureFormatName##FormatName = FName(TEXT(#FormatName));
ENUM_SUPPORTED_FORMATS(DECL_FORMAT_NAME);
#undef DECL_FORMAT_NAME
#define DECL_FORMAT_NAME_ENTRY(FormatName) GTextureFormatName##FormatName ,
static FName GSupportedTextureFormatNames[] =
{
ENUM_SUPPORTED_FORMATS(DECL_FORMAT_NAME_ENTRY)
};
#undef DECL_FORMAT_NAME_ENTRY
#undef ENUM_SUPPORTED_FORMATS
/**
* note : ASTC formats are NOT in the GSupportedTextureFormatNames
* so we are not registered to support them
* they will call into TextureFormatASTC and then optionally redirect to here
* this just defines the FNames
*/
#define ENUM_ASTC_FORMATS(op) \
op(ASTC_RGB) \
op(ASTC_RGBA) \
op(ASTC_RGBAuto) \
op(ASTC_RGBA_HQ) \
op(ASTC_RGB_HDR) \
op(ASTC_NormalAG) \
op(ASTC_NormalRG)
#define DECL_FORMAT_NAME(FormatName) static FName GTextureFormatName##FormatName = FName(TEXT(#FormatName));
ENUM_ASTC_FORMATS(DECL_FORMAT_NAME);
#undef DECL_FORMAT_NAME
#undef ENUM_ASTC_FORMATS
// BC6H, BC7, ASTC all have 16-byte block size
#define BLOCK_SIZE_IN_BYTES 16
#if DEBUG_SAVE_INTERMEDIATE_IMAGES
namespace
{
// Bitmap compression types.
enum EBitmapCompression
{
BCBI_RGB = 0,
BCBI_RLE8 = 1,
BCBI_RLE4 = 2,
BCBI_BITFIELDS = 3,
};
// .BMP file header.
#pragma pack(push,1)
struct FBitmapFileHeader
{
uint16 bfType;
uint32 bfSize;
uint16 bfReserved1;
uint16 bfReserved2;
uint32 bfOffBits;
friend FArchive& operator<<(FArchive& Ar, FBitmapFileHeader& H)
{
Ar << H.bfType << H.bfSize << H.bfReserved1 << H.bfReserved2 << H.bfOffBits;
return Ar;
}
};
#pragma pack(pop)
// .BMP subheader.
#pragma pack(push,1)
struct FBitmapInfoHeader
{
uint32 biSize;
uint32 biWidth;
int32 biHeight;
uint16 biPlanes;
uint16 biBitCount;
uint32 biCompression;
uint32 biSizeImage;
uint32 biXPelsPerMeter;
uint32 biYPelsPerMeter;
uint32 biClrUsed;
uint32 biClrImportant;
friend FArchive& operator<<(FArchive& Ar, FBitmapInfoHeader& H)
{
Ar << H.biSize << H.biWidth << H.biHeight;
Ar << H.biPlanes << H.biBitCount;
Ar << H.biCompression << H.biSizeImage;
Ar << H.biXPelsPerMeter << H.biYPelsPerMeter;
Ar << H.biClrUsed << H.biClrImportant;
return Ar;
}
};
#pragma pack(pop)
static void SaveImageAsBMP( FArchive& Ar, const uint8* RawData, int SourceBytesPerPixel, int SizeX, int SizeY )
{
FBitmapFileHeader bmf;
FBitmapInfoHeader bmh;
// File header.
bmf.bfType = 'B' + (256 * (int32)'M');
bmf.bfReserved1 = 0;
bmf.bfReserved2 = 0;
int32 biSizeImage = SizeX * SizeY * 3;
bmf.bfOffBits = sizeof(FBitmapFileHeader) + sizeof(FBitmapInfoHeader);
bmh.biBitCount = 24;
bmf.bfSize = bmf.bfOffBits + biSizeImage;
Ar << bmf;
// Info header.
bmh.biSize = sizeof(FBitmapInfoHeader);
bmh.biWidth = SizeX;
bmh.biHeight = SizeY;
bmh.biPlanes = 1;
bmh.biCompression = BCBI_RGB;
bmh.biSizeImage = biSizeImage;
bmh.biXPelsPerMeter = 0;
bmh.biYPelsPerMeter = 0;
bmh.biClrUsed = 0;
bmh.biClrImportant = 0;
Ar << bmh;
bool bIsRGBA16 = (SourceBytesPerPixel == 8);
//NOTE: Each row must be 4-byte aligned in a BMP.
int PaddingX = Align(SizeX * 3, 4) - SizeX * 3;
// Upside-down scanlines.
for (int32 i = SizeY - 1; i >= 0; i--)
{
const uint8* ScreenPtr = &RawData[i*SizeX*SourceBytesPerPixel];
for (int32 j = SizeX; j > 0; j--)
{
uint8 R, G, B;
if (bIsRGBA16)
{
R = ScreenPtr[1];
G = ScreenPtr[3];
B = ScreenPtr[5];
ScreenPtr += 8;
}
else
{
R = ScreenPtr[0];
G = ScreenPtr[1];
B = ScreenPtr[2];
ScreenPtr += 4;
}
Ar << R;
Ar << G;
Ar << B;
}
for (int32 j = 0; j < PaddingX; ++j)
{
int8 PadByte = 0;
Ar << PadByte;
}
}
}
#define MAGIC_FILE_CONSTANT 0x5CA1AB13
// little endian
#pragma pack(push,1)
struct astc_header
{
uint8_t magic[4];
uint8_t blockdim_x;
uint8_t blockdim_y;
uint8_t blockdim_z;
uint8_t xsize[3];
uint8_t ysize[3]; // x-size, y-size and z-size are given in texels;
uint8_t zsize[3]; // block count is inferred
};
#pragma pack(pop)
static void SaveImageAsASTC(FArchive& Ar, uint8* RawData, int SizeX, int SizeY, int block_width, int block_height)
{
astc_header file_header;
uint32_t magic = MAGIC_FILE_CONSTANT;
FMemory::Memcpy(file_header.magic, &magic, 4);
file_header.blockdim_x = block_width;
file_header.blockdim_y = block_height;
file_header.blockdim_z = 1;
int32 xsize = SizeX;
int32 ysize = SizeY;
int32 zsize = 1;
FMemory::Memcpy(file_header.xsize, &xsize, 3);
FMemory::Memcpy(file_header.ysize, &ysize, 3);
FMemory::Memcpy(file_header.zsize, &zsize, 3);
Ar.Serialize(&file_header, sizeof(file_header));
size_t height_in_blocks = (SizeY + block_height - 1) / block_height;
size_t width_in_blocks = (SizeX + block_width - 1) / block_width;
int stride = width_in_blocks * BLOCK_SIZE_IN_BYTES;
Ar.Serialize(RawData, height_in_blocks * stride);
}
}; // namespace
#endif
// DEBUG_SAVE_INTERMEDIATE_IMAGES
struct FMultithreadSettings
{
int iScansPerTask;
int iNumTasks;
};
template <typename EncoderSettingsType>
struct FMultithreadedCompression
{
typedef void(*CompressFunction)(EncoderSettingsType* pEncSettings, FImage* pInImage, FCompressedImage2D* pOutImage, int yStart, int yEnd, int SliceIndex);
static void Compress(FMultithreadSettings &MultithreadSettings, EncoderSettingsType &EncoderSettings, FImage &Image, FCompressedImage2D &OutCompressedImage, CompressFunction FunctionCallback, bool bUseTasks)
{
if (bUseTasks)
{
class FIntelCompressWorker
{
public:
FIntelCompressWorker(EncoderSettingsType* pEncSettings, FImage* pInImage, FCompressedImage2D* pOutImage, int yStart, int yEnd, int SliceIndex, CompressFunction InFunctionCallback)
: mpEncSettings(pEncSettings)
, mpInImage(pInImage)
, mpOutImage(pOutImage)
, mYStart(yStart)
, mYEnd(yEnd)
, mSliceIndex(SliceIndex)
, mCallback(InFunctionCallback)
{
}
void DoWork()
{
mCallback(mpEncSettings, mpInImage, mpOutImage, mYStart, mYEnd, mSliceIndex);
}
EncoderSettingsType* mpEncSettings;
FImage* mpInImage;
FCompressedImage2D* mpOutImage;
int mYStart;
int mYEnd;
int mSliceIndex;
CompressFunction mCallback;
};
// One less task because we'll do the final + non multiple of 4 inside this task
TArray<FIntelCompressWorker> CompressionTasks;
const int NumStasksPerSlice = MultithreadSettings.iNumTasks + 1;
CompressionTasks.Reserve(NumStasksPerSlice * Image.NumSlices - 1);
for (int SliceIndex = 0; SliceIndex < Image.NumSlices; ++SliceIndex)
{
for (int iTask = 0; iTask < NumStasksPerSlice; ++iTask)
{
// Create a new task unless it's the last task in the last slice (that one will run on current thread, after these threads have been started)
if (SliceIndex < (Image.NumSlices - 1) || iTask < (NumStasksPerSlice - 1))
{
CompressionTasks.Emplace(&EncoderSettings, &Image, &OutCompressedImage, iTask * MultithreadSettings.iScansPerTask, (iTask + 1) * MultithreadSettings.iScansPerTask, SliceIndex, FunctionCallback);
}
}
}
ParallelForWithPreWork(CompressionTasks.Num(), [&CompressionTasks](int32 TaskIndex)
{
CompressionTasks[TaskIndex].DoWork();
},
[&EncoderSettings, &Image, &OutCompressedImage, &MultithreadSettings, &FunctionCallback]()
{
FunctionCallback(&EncoderSettings, &Image, &OutCompressedImage, MultithreadSettings.iScansPerTask * MultithreadSettings.iNumTasks, Image.SizeY, Image.NumSlices - 1);
}, EParallelForFlags::Unbalanced);
}
else
{
for (int SliceIndex = 0; SliceIndex < Image.NumSlices; ++SliceIndex)
{
FunctionCallback(&EncoderSettings, &Image, &OutCompressedImage, 0, Image.SizeY, SliceIndex);
}
}
}
};
/**
* BC6H Compression function
*/
static void IntelBC6HCompressScans(bc6h_enc_settings* pEncSettings, FImage* pInImage, FCompressedImage2D* pOutImage, int yStart, int yEnd, int SliceIndex)
{
check(pInImage->Format == ERawImageFormat::RGBA16F);
check((yStart % 4) == 0);
// sizes are padded to multiple of 4 for ISPC by PadImageToBlockSize :
check((pInImage->SizeX % 4) == 0);
check((yStart >= 0) && (yStart <= pInImage->SizeY));
check((yEnd >= 0) && (yEnd <= pInImage->SizeY));
const int64 InStride = (int64)pInImage->SizeX * 8;
const int64 OutStride = (int64)((pInImage->SizeX + 3) / 4) * BLOCK_SIZE_IN_BYTES;
const int64 InSliceSize = (int64)pInImage->SizeY * InStride;
const int64 OutSliceSize = (int64)((pInImage->SizeY +3) / 4) * OutStride;
uint8* pInTexels = reinterpret_cast<uint8*>(&pInImage->RawData[0]) + InSliceSize * SliceIndex;
uint8* pOutTexels = reinterpret_cast<uint8*>(&pOutImage->RawData[0]) + OutSliceSize * SliceIndex;
rgba_surface insurface;
insurface.ptr = pInTexels + (yStart * InStride);
insurface.width = pInImage->SizeX;
insurface.height = yEnd - yStart;
insurface.stride = pInImage->SizeX * 8;
pOutTexels += yStart / 4 * OutStride;
CompressBlocksBC6H(&insurface, pOutTexels, pEncSettings);
}
/**
* BC7 Compression function
*/
static void IntelBC7CompressScans(bc7_enc_settings* pEncSettings, FImage* pInImage, FCompressedImage2D* pOutImage, int yStart, int yEnd, int SliceIndex)
{
check(pInImage->Format == ERawImageFormat::BGRA8);
check((yStart % 4) == 0);
// sizes are padded to multiple of 4 for ISPC by PadImageToBlockSize :
check((pInImage->SizeX % 4) == 0);
check((yStart >= 0) && (yStart <= pInImage->SizeY));
check((yEnd >= 0) && (yEnd <= pInImage->SizeY));
const int64 InStride = (int64)pInImage->SizeX * 4;
const int64 OutStride = (int64)((pInImage->SizeX + 3) / 4) * BLOCK_SIZE_IN_BYTES;
const int64 InSliceSize = (int64)pInImage->SizeY * InStride;
const int64 OutSliceSize = (int64)((pInImage->SizeY + 3) / 4) * OutStride;
uint8* pInTexels = reinterpret_cast<uint8*>(&pInImage->RawData[0]) + InSliceSize * SliceIndex;
uint8* pOutTexels = reinterpret_cast<uint8*>(&pOutImage->RawData[0]) + OutSliceSize * SliceIndex;
// Switch byte order for compressors input
for ( int y=yStart; y < yEnd; ++y )
{
uint8* pInTexelsSwap = pInTexels + (y * InStride);
for ( int x=0; x < pInImage->SizeX; ++x )
{
const uint8 r = pInTexelsSwap[0];
pInTexelsSwap[0] = pInTexelsSwap[2];
pInTexelsSwap[2] = r;
pInTexelsSwap += 4;
}
}
rgba_surface insurface;
insurface.ptr = pInTexels + (yStart * InStride);
insurface.width = pInImage->SizeX;
insurface.height = yEnd - yStart;
insurface.stride = pInImage->SizeX * 4;
pOutTexels += yStart / 4 * OutStride;
CompressBlocksBC7(&insurface, pOutTexels, pEncSettings);
}
#define MAX_QUALITY_BY_SIZE 4
static uint16 GetDefaultCompressionBySizeValue(FCbObjectView InFormatConfigOverride)
{
// this is code duped between TextureFormatASTC and TextureFormatISPC
if (InFormatConfigOverride)
{
// If we have an explicit format config, then use it directly
FCbFieldView FieldView = InFormatConfigOverride.FindView("DefaultASTCQualityBySize");
checkf(FieldView.HasValue(), TEXT("Missing DefaultASTCQualityBySize key from FormatConfigOverride"));
int32 CompressionModeValue = FieldView.AsInt32();
checkf(!FieldView.HasError(), TEXT("Failed to parse DefaultASTCQualityBySize value from FormatConfigOverride"));
return IntCastChecked<uint16>(CompressionModeValue);
}
else
{
// default of 0 == 12x12 ?
// BaseEngine.ini sets DefaultASTCQualityBySize to 3 == 6x6
auto GetCompressionModeValue = []() {
// start at default quality, then lookup in .ini file
int32 CompressionModeValue = 0;
GConfig->GetInt(TEXT("/Script/UnrealEd.CookerSettings"), TEXT("DefaultASTCQualityBySize"), CompressionModeValue, GEngineIni);
FParse::Value(FCommandLine::Get(), TEXT("-astcqualitybysize="), CompressionModeValue);
return FMath::Min<uint32>(CompressionModeValue, MAX_QUALITY_BY_SIZE);
};
static uint16 CompressionModeValue = IntCastChecked<uint16>(GetCompressionModeValue());
return CompressionModeValue;
}
}
static EPixelFormat GetASTCQualityFormat(int& BlockWidth, int& BlockHeight, const FTextureBuildSettings& BuildSettings)
{
// code dupe between TextureFormatASTC and TextureFormatISPC
const FCbObjectView& InFormatConfigOverride = BuildSettings.FormatConfigOverride;
int32 OverrideSizeValue= BuildSettings.CompressionQuality;
bool bIsNormalMap = (BuildSettings.TextureFormatName == GTextureFormatNameASTC_NormalAG || BuildSettings.TextureFormatName == GTextureFormatNameASTC_NormalRG);
bool bIsHQ = BuildSettings.TextureFormatName == GTextureFormatNameASTC_RGBA_HQ;
bool bHDRFormat = BuildSettings.TextureFormatName == GTextureFormatNameASTC_RGB_HDR;
check( ! bHDRFormat ); // HDR not supported here
if ( bIsNormalMap )
{
BlockWidth = BlockHeight = 6;
return PF_ASTC_6x6;
}
else if ( bIsHQ || BuildSettings.bVirtualStreamable )
{
// NOTE: different than TextureFormatASTC which configurable HQ block size
BlockWidth = BlockHeight = 4;
return PF_ASTC_4x4;
}
// Note: ISPC only supports 8x8 and higher quality, and only one speed (fast)
EPixelFormat Format = PF_Unknown;
switch (OverrideSizeValue >= 0 ? OverrideSizeValue : GetDefaultCompressionBySizeValue(InFormatConfigOverride))
{
// NOTE: different than TextureFormatASTC which has the 10 and 12 size blocks here
case 0: //Format = PF_ASTC_12x12; BlockWidth = BlockHeight = 12; break;
case 1: //Format = PF_ASTC_10x10; BlockWidth = BlockHeight = 10; break;
case 2: Format = PF_ASTC_8x8; BlockWidth = BlockHeight = 8; break;
case 3: Format = PF_ASTC_6x6; BlockWidth = BlockHeight = 6; break;
case 4: Format = PF_ASTC_4x4; BlockWidth = BlockHeight = 4; break;
default: UE_LOG(LogTemp, Fatal, TEXT("Max quality higher than expected"));
}
return Format;
}
struct FASTCEncoderSettings : public astc_enc_settings
{
FName TextureFormatName;
bool bISPCTexcompNormalizeNormals = false;
FASTCEncoderSettings()
{
// ensure astc_enc_settings are initialized :
astc_enc_settings * parent = this;
memset(parent,0,sizeof(*parent));
}
};
/**
* ASTC Compression function
*/
static void IntelASTCCompressScans(FASTCEncoderSettings* pEncSettings, FImage* pInImage, FCompressedImage2D* pOutImage, int yStart, int yEnd, int SliceIndex)
{
check(pInImage->Format == ERawImageFormat::BGRA8);
check((yStart % pEncSettings->block_height) == 0);
// sizes are padded for ISPC by PadImageToBlockSize :
check((pInImage->SizeX % pEncSettings->block_width) == 0);
check((yStart >= 0) && (yStart <= pInImage->SizeY));
check((yEnd >= 0) && (yEnd <= pInImage->SizeY));
const int64 InStride = (int64)pInImage->SizeX * 4;
const int64 OutStride = (int64)FMath::DivideAndRoundUp( pInImage->SizeX , pEncSettings->block_width) * BLOCK_SIZE_IN_BYTES;
const int64 InSliceSize = (int64)pInImage->SizeY * InStride;
const int64 OutSliceSize = (int64)FMath::DivideAndRoundUp( pInImage->SizeY , pEncSettings->block_height) * OutStride;
uint8* pInTexels = reinterpret_cast<uint8*>(&pInImage->RawData[0]) + InSliceSize * SliceIndex;
uint8* pOutTexels = reinterpret_cast<uint8*>(&pOutImage->RawData[0]) + OutSliceSize * SliceIndex;
// TextureFormatName at this point should no longer be RGBAuto
// it's mapped to _RGB or _RGBA concretely
if (pEncSettings->TextureFormatName == GTextureFormatNameASTC_RGB)
{
// Switch byte order for compressors input (BGRA -> RGBA)
// Force A=255
for (int y = yStart; y < yEnd; ++y)
{
uint8* pInTexelsSwap = pInTexels + (y * InStride);
for (int x = 0; x < pInImage->SizeX; ++x)
{
const uint8 r = pInTexelsSwap[0];
pInTexelsSwap[0] = pInTexelsSwap[2];
pInTexelsSwap[2] = r;
pInTexelsSwap[3] = 255;
pInTexelsSwap += 4;
}
}
}
else if (pEncSettings->TextureFormatName == GTextureFormatNameASTC_RGBA || pEncSettings->TextureFormatName == GTextureFormatNameASTC_RGBA_HQ)
{
// Switch byte order for compressors input (BGRA -> RGBA)
for (int y = yStart; y < yEnd; ++y)
{
uint8* pInTexelsSwap = pInTexels + (y * InStride);
for (int x = 0; x < pInImage->SizeX; ++x)
{
const uint8 r = pInTexelsSwap[0];
pInTexelsSwap[0] = pInTexelsSwap[2];
pInTexelsSwap[2] = r;
pInTexelsSwap += 4;
}
}
}
else if (pEncSettings->TextureFormatName == GTextureFormatNameASTC_NormalAG)
{
// input BGRA -> output 0,G,0,A
if ( pEncSettings->bISPCTexcompNormalizeNormals )
{
// legacy behavior:
// Re-normalize normals before dropping components
// this is right, but doing it here makes this TextureFormat inconsistent with all others
for (int y = yStart; y < yEnd; ++y)
{
uint8* pInTexelsSwap = pInTexels + (y * InStride);
for (int x = 0; x < pInImage->SizeX; ++x)
{
FVector Normal = FVector(pInTexelsSwap[2] / 255.0f * 2.0f - 1.0f, pInTexelsSwap[1] / 255.0f * 2.0f - 1.0f, pInTexelsSwap[0] / 255.0f * 2.0f - 1.0f);
Normal = Normal.GetSafeNormal();
pInTexelsSwap[0] = 0;
pInTexelsSwap[1] = static_cast<uint8>(FMath::RoundToInt((Normal.Y * 0.5f + 0.5f) * 255.f));
pInTexelsSwap[2] = 0;
pInTexelsSwap[3] = static_cast<uint8>(FMath::RoundToInt((Normal.X * 0.5f + 0.5f) * 255.f));
pInTexelsSwap += 4;
}
}
}
else
{
// new preferred path: do not normalize normals here, use bNormalizeNormals in TextureCompressor
for (int y = yStart; y < yEnd; ++y)
{
uint8* pInTexelsSwap = pInTexels + (y * InStride);
for (int x = 0; x < pInImage->SizeX; ++x)
{
pInTexelsSwap[0] = 0;
//pInTexelsSwap[1] = pInTexelsSwap[1]; // G
pInTexelsSwap[3] = pInTexelsSwap[2]; // R->A
pInTexelsSwap[2] = 0;
pInTexelsSwap += 4;
}
}
}
}
else if (pEncSettings->TextureFormatName == GTextureFormatNameASTC_NormalRG)
{
// input BGRA -> output RG,0,255
if ( pEncSettings->bISPCTexcompNormalizeNormals )
{
// legacy behavior:
// Re-normalize normals before dropping components
// this is right, but doing it here makes this TextureFormat inconsistent with all others
for (int y = yStart; y < yEnd; ++y)
{
uint8* pInTexelsSwap = pInTexels + (y * InStride);
for (int x = 0; x < pInImage->SizeX; ++x)
{
FVector Normal = FVector(pInTexelsSwap[2] / 255.0f * 2.0f - 1.0f, pInTexelsSwap[1] / 255.0f * 2.0f - 1.0f, pInTexelsSwap[0] / 255.0f * 2.0f - 1.0f);
Normal = Normal.GetSafeNormal();
pInTexelsSwap[0] = static_cast<uint8>(FMath::RoundToInt((Normal.X * 0.5f + 0.5f) * 255.f));
pInTexelsSwap[1] = static_cast<uint8>(FMath::RoundToInt((Normal.Y * 0.5f + 0.5f) * 255.f));
pInTexelsSwap[2] = 0;
pInTexelsSwap[3] = 255;
pInTexelsSwap += 4;
}
}
}
else
{
// new preferred path: do not normalize normals here, use bNormalizeNormals in TextureCompressor
for (int y = yStart; y < yEnd; ++y)
{
uint8* pInTexelsSwap = pInTexels + (y * InStride);
for (int x = 0; x < pInImage->SizeX; ++x)
{
pInTexelsSwap[0] = pInTexelsSwap[2]; // R
//pInTexelsSwap[1] = pInTexelsSwap[1]; // G
pInTexelsSwap[2] = 0;
pInTexelsSwap[3] = 255;
pInTexelsSwap += 4;
}
}
}
}
else
{
checkNoEntry();
}
rgba_surface insurface;
insurface.ptr = pInTexels + (yStart * InStride);
insurface.width = pInImage->SizeX;
insurface.height = yEnd - yStart;
insurface.stride = pInImage->SizeX * 4;
check((yStart % pEncSettings->block_height) == 0);
pOutTexels += (yStart / pEncSettings->block_height) * OutStride;
CompressBlocksASTC(&insurface, pOutTexels, pEncSettings);
}
/**
* Intel BC texture format handler.
*/
class FTextureFormatIntelISPCTexComp : public ITextureFormat
{
public:
void* mDllHandle = nullptr;
FTextureFormatIntelISPCTexComp()
{
}
virtual ~FTextureFormatIntelISPCTexComp()
{
if ( mDllHandle != nullptr )
{
FPlatformProcess::FreeDllHandle(mDllHandle);
mDllHandle = nullptr;
}
}
void LoadDLLOnce()
{
// LoadDLL is delayed to first use
// should only be called once
check( mDllHandle == nullptr );
FString DLLPath;
#if PLATFORM_WINDOWS
DLLPath = FPaths::EngineDir() / TEXT("Binaries/ThirdParty/Intel/ISPCTexComp/Win64-Release/ispc_texcomp.dll");
#elif PLATFORM_MAC
DLLPath = FPaths::EngineDir() / TEXT("Binaries/ThirdParty/Intel/ISPCTexComp/Mac64-Release/libispc_texcomp.dylib");
#elif PLATFORM_LINUX
DLLPath = FPaths::EngineDir() / TEXT("Binaries/ThirdParty/Intel/ISPCTexComp/Linux64-Release/libispc_texcomp.so");
#endif
if (DLLPath.Len() > 0)
{
mDllHandle = FPlatformProcess::GetDllHandle(*DLLPath);
UE_CLOG(mDllHandle == nullptr, LogTextureFormatIntelISPCTexComp, Error, TEXT("Unable to load %s"), *DLLPath);
}
else
{
UE_LOG(LogTextureFormatIntelISPCTexComp, Error, TEXT("Platform does not have an ispc_texcomp DLL/library"));
}
}
virtual bool AllowParallelBuild() const override
{
return true;
}
virtual FName GetEncoderName(FName Format) const override
{
static const FName IntelName("IntelISPC");
return IntelName;
}
virtual FCbObject ExportGlobalFormatConfig(const FTextureBuildSettings& BuildSettings) const override
{
FCbWriter Writer;
Writer.BeginObject("TextureFormatIntelISPCTexCompSettings");
Writer.AddInteger("DefaultASTCQualityBySize", GetDefaultCompressionBySizeValue(FCbObjectView()));
Writer.EndObject();
return Writer.Save().AsObject();
}
// Return the version for the DX11 formats BC6H and BC7 (not ASTC)
virtual uint16 GetVersion(
FName Format,
const FTextureBuildSettings* BuildSettings = nullptr
) const override
{
return BASE_ISPC_DX11_FORMAT_VERSION;
}
virtual FString GetDerivedDataKeyString(const FTextureBuildSettings& InBuildSettings, int32 InMipCount, const FIntVector3& InMip0Dimensions) const override
{
// ASTC block size chosen is in PixelFormat
EPixelFormat PixelFormat = GetPixelFormatForBuildSettings(InBuildSettings);
return FString::Printf(TEXT("ISPC_%d"), (int)PixelFormat);
}
virtual void GetSupportedFormats(TArray<FName>& OutFormats) const override
{
OutFormats.Append(GSupportedTextureFormatNames, UE_ARRAY_COUNT(GSupportedTextureFormatNames));
}
static void SetupScans(const FImage& InImage, int BlockWidth, int BlockHeight, FCompressedImage2D& OutCompressedImage, FMultithreadSettings &MultithreadSettings)
{
const int AlignedSizeX = AlignArbitrary(InImage.SizeX, BlockWidth);
const int AlignedSizeY = AlignArbitrary(InImage.SizeY, BlockHeight);
const int WidthInBlocks = AlignedSizeX / BlockWidth;
const int HeightInBlocks = AlignedSizeY / BlockHeight;
const int64 SizePerSlice = (int64)WidthInBlocks * HeightInBlocks * BLOCK_SIZE_IN_BYTES;
// ISPC pads sizes, but OutCompressedImage gets the unpadded sizes :
OutCompressedImage.RawData.AddUninitialized(SizePerSlice * InImage.NumSlices);
OutCompressedImage.SizeX = InImage.SizeX;
OutCompressedImage.SizeY = InImage.SizeY;
// When we allow async tasks to execute we do so with BlockHeight lines of the image per task
// This isn't optimal for long thin textures, but works well with how ISPC works
MultithreadSettings.iScansPerTask = BlockHeight;
MultithreadSettings.iNumTasks = FMath::Max((AlignedSizeY / MultithreadSettings.iScansPerTask) - 1, 0);
}
static void PadImageToBlockSize(FImage &InOutImage, int BlockWidth, int BlockHeight, int BytesPerPixel)
{
const int AlignedSizeX = AlignArbitrary(InOutImage.SizeX, BlockWidth);
const int AlignedSizeY = AlignArbitrary(InOutImage.SizeY, BlockHeight);
const int64 AlignedSliceSize = (int64)AlignedSizeX * AlignedSizeY * BytesPerPixel;
const int64 AlignedTotalSize = AlignedSliceSize * InOutImage.NumSlices;
const int64 OriginalSliceSize = (int64)InOutImage.SizeX * InOutImage.SizeY * BytesPerPixel;
// Early out if no padding is necessary
if (AlignedSizeX == InOutImage.SizeX && AlignedSizeY == InOutImage.SizeY)
{
return;
}
// ISPCtexcomp crashes on images not of block-aligned size
// Allocate temp buffer
TArray64<uint8> TempBuffer;
TempBuffer.SetNumUninitialized(AlignedTotalSize);
const int PaddingX = AlignedSizeX - InOutImage.SizeX;
const int PaddingY = AlignedSizeY - InOutImage.SizeY;
const int SrcStride = InOutImage.SizeX * BytesPerPixel;
const int DstStride = AlignedSizeX * BytesPerPixel;
for (int SliceIndex = 0; SliceIndex < InOutImage.NumSlices; ++SliceIndex)
{
uint8* DstData = ((uint8*)TempBuffer.GetData()) + SliceIndex * AlignedSliceSize;
const uint8* SrcData = ((uint8*)InOutImage.RawData.GetData()) + SliceIndex * OriginalSliceSize;
// Copy all of SrcData and pad on X-axis:
for (int Y = 0; Y < InOutImage.SizeY; ++Y)
{
FMemory::Memcpy(DstData, SrcData, SrcStride);
SrcData += SrcStride - BytesPerPixel; // Src: Last pixel on this row
DstData += SrcStride; // Dst: Beginning of the padded region at the end of this row
for (int PadX = 0; PadX < PaddingX; PadX++)
{
// Replicate right-most pixel as padding on X-axis
FMemory::Memcpy(DstData, SrcData, BytesPerPixel);
DstData += BytesPerPixel;
}
SrcData += BytesPerPixel; // Src & Dst: Beginning of next row
}
// Replicate last row as padding on Y-axis:
SrcData = DstData - DstStride; // Src: Beginning of the last row (of DstData)
for (int PadY = 0; PadY < PaddingY; PadY++)
{
FMemory::Memcpy(DstData, SrcData, DstStride);
DstData += DstStride; // Dst: Beginning of the padded region at the end of this row
}
}
// Replace InOutImage with the new data
InOutImage.RawData = MoveTemp(TempBuffer);
InOutImage.SizeX = AlignedSizeX;
InOutImage.SizeY = AlignedSizeY;
}
virtual EPixelFormat GetEncodedPixelFormat(const FTextureBuildSettings& InBuildSettings, bool bInImageHasAlphaChannel) const override
{
return GetPixelFormatForBuildSettings(InBuildSettings);
}
EPixelFormat GetPixelFormatForBuildSettings(const FTextureBuildSettings& BuildSettings) const
{
if (BuildSettings.TextureFormatName == GTextureFormatNameBC6H)
{
return PF_BC6H;
}
else if (BuildSettings.TextureFormatName == GTextureFormatNameBC7)
{
return PF_BC7;
}
else
{
int _Width, _Height;
return GetASTCQualityFormat(_Width, _Height, BuildSettings);
}
}
virtual bool CompressImage(
const FImage& InImage,
const FTextureBuildSettings& BuildSettings,
const FIntVector3& InMip0Dimensions,
int32 InMip0NumSlicesNoDepth,
int32 InMipIndex,
int32 InMipCount,
FStringView DebugTexturePathName,
bool bImageHasAlphaChannel,
FCompressedImage2D& OutCompressedImage
) const override
{
check(InImage.SizeX > 0);
check(InImage.SizeY > 0);
check(InImage.NumSlices > 0);
// Load DLL on first use :
UE_CALL_ONCE( const_cast<FTextureFormatIntelISPCTexComp *>(this)->LoadDLLOnce );
bool bCompressionSucceeded = false;
int BlockWidth = 0;
int BlockHeight = 0;
const bool bUseTasks = true;
FMultithreadSettings MultithreadSettings;
EPixelFormat CompressedPixelFormat = GetEncodedPixelFormat(BuildSettings, bImageHasAlphaChannel);
if ( BuildSettings.TextureFormatName == GTextureFormatNameBC6H )
{
FImage Image;
InImage.CopyTo(Image, ERawImageFormat::RGBA16F, EGammaSpace::Linear);
FImageCore::SanitizeFloat16AndSetAlphaOpaqueForBC6H(Image);
bc6h_enc_settings settings;
GetProfile_bc6h_basic(&settings);
SetupScans(Image, 4, 4, OutCompressedImage, MultithreadSettings);
PadImageToBlockSize(Image, 4, 4, 4*2);
FMultithreadedCompression<bc6h_enc_settings>::Compress(MultithreadSettings, settings, Image, OutCompressedImage, &IntelBC6HCompressScans, bUseTasks);
bCompressionSucceeded = true;
}
else if ( BuildSettings.TextureFormatName == GTextureFormatNameBC7 )
{
FImage Image;
InImage.CopyTo(Image, ERawImageFormat::BGRA8, BuildSettings.GetDestGammaSpace());
bc7_enc_settings settings;
if ( bImageHasAlphaChannel )
{
GetProfile_alpha_basic(&settings);
}
else
{
GetProfile_basic(&settings);
}
SetupScans(Image, 4, 4, OutCompressedImage, MultithreadSettings);
PadImageToBlockSize(Image, 4, 4, 4*1);
FMultithreadedCompression<bc7_enc_settings>::Compress(MultithreadSettings, settings, Image, OutCompressedImage, &IntelBC7CompressScans, bUseTasks);
bCompressionSucceeded = true;
}
else
{
bool bIsNormalMap = (BuildSettings.TextureFormatName == GTextureFormatNameASTC_NormalAG ||
BuildSettings.TextureFormatName == GTextureFormatNameASTC_NormalRG);
bool bHDRImage = BuildSettings.TextureFormatName == GTextureFormatNameASTC_RGB_HDR;
check( ! bHDRImage ); // HDR not supported here
GetASTCQualityFormat( BlockWidth, BlockHeight, BuildSettings );
FASTCEncoderSettings EncoderSettings;
EncoderSettings.TextureFormatName = BuildSettings.TextureFormatName;
if ( bIsNormalMap )
{
check( BlockWidth == 6 && BlockHeight == 6 );
if (BuildSettings.TextureFormatName == GTextureFormatNameASTC_NormalAG)
{
GetProfile_astc_alpha_fast(&EncoderSettings, BlockWidth, BlockHeight);
}
else if (BuildSettings.TextureFormatName == GTextureFormatNameASTC_NormalRG)
{
GetProfile_astc_fast(&EncoderSettings, BlockWidth, BlockHeight);
}
else
{
checkNoEntry();
}
if ( BuildSettings.bNormalizeNormals || BuildSettings.bUseNewMipFilter )
{
// newer texture build, do NOT normalize normals here
// it is done by bNormalizeNormals if wanted, at the TextureCompressor level before getting to the TextureFormat
EncoderSettings.bISPCTexcompNormalizeNormals = false;
}
else
{
// old texture build
// enable legacy behavior to maintain same output
// we would prefer bISPCTexcompNormalizeNormals to just always be off and use bNormalizeNormals instead
EncoderSettings.bISPCTexcompNormalizeNormals = true;
}
}
else
{
if( BuildSettings.TextureFormatName == GTextureFormatNameASTC_RGB || !bImageHasAlphaChannel )
{
// even if Name was RGBA we still use the RGB profile if !bImageHasAlphaChannel
// so that "Compress Without Alpha" can force us to opaque
EncoderSettings.TextureFormatName = GTextureFormatNameASTC_RGB; // <- this will force A to 255 in IntelASTCCompressScans
GetProfile_astc_fast(&EncoderSettings, BlockWidth, BlockHeight);
}
else
{
EncoderSettings.TextureFormatName = GTextureFormatNameASTC_RGBA;
GetProfile_astc_alpha_fast(&EncoderSettings, BlockWidth, BlockHeight);
}
}
{
check(EncoderSettings.block_width!=0);
FImage Image;
InImage.CopyTo(Image, ERawImageFormat::BGRA8, BuildSettings.GetDestGammaSpace());
SetupScans(Image, EncoderSettings.block_width, EncoderSettings.block_height, OutCompressedImage, MultithreadSettings);
PadImageToBlockSize(Image, EncoderSettings.block_width, EncoderSettings.block_height, 4 * 1);
#if DEBUG_SAVE_INTERMEDIATE_IMAGES
// To DebugDump specific files, modify DebugDumpFilter here
// (currently not exposed to command line, but could be)
//static FString DebugDumpFilter(TEXT("*DummySpriteTexture*"));;
static FString DebugDumpFilter(TEXT("*"));
//static FString DebugDumpFilter;
bool SaveInputOutput = false;
if ( ! DebugDumpFilter.IsEmpty() )
{
SaveInputOutput = FWildcardString::IsMatchSubstring(*DebugDumpFilter, DebugTexturePathName.GetData(), DebugTexturePathName.GetData() + DebugTexturePathName.Len(), ESearchCase::IgnoreCase);
}
FString DebugDumpFileNameBase;
if (SaveInputOutput)
{
FString FileName = FString::Printf(TEXT("%.*s_%dx%d_%s_%dx%d"), DebugTexturePathName.Len(), DebugTexturePathName.GetData(),
Image.SizeX, Image.SizeY, *BuildSettings.TextureFormatName.ToString(), BlockWidth,BlockHeight);
// Object paths a) can contain slashes as its a path, and we dont want a hierarchy and b) can have random characters we don't want
FileName = FPaths::MakeValidFileName(FileName, TEXT('_'));
FileName = FPaths::ProjectSavedDir() + TEXT("ISPCDebugImages/") + FileName;
// limit to _MAX_PATH
if ( FileName.Len() >= 256 )
{
FileName = FileName.Right(255);
}
DebugDumpFileNameBase = FileName;
}
if (SaveInputOutput)
{
const FString FileName = FString::Printf(TEXT("%s-in.bmp"), *DebugDumpFileNameBase );
FArchive* FileWriter = IFileManager::Get().CreateFileWriter(*FileName);
SaveImageAsBMP(*FileWriter, Image.RawData.GetData(), 4, Image.SizeX, Image.SizeY);
delete FileWriter;
}
#endif
FMultithreadedCompression<FASTCEncoderSettings>::Compress(MultithreadSettings, EncoderSettings, Image, OutCompressedImage, &IntelASTCCompressScans, bUseTasks);
bCompressionSucceeded = true;
#if DEBUG_SAVE_INTERMEDIATE_IMAGES
// (save swizzled/fixed-up input as BMP):
if (SaveInputOutput)
{
const FString FileName = FString::Printf(TEXT("%s-in-swiz.bmp"), *DebugDumpFileNameBase );
FArchive* FileWriter = IFileManager::Get().CreateFileWriter(*FileName);
SaveImageAsBMP(*FileWriter, Image.RawData.GetData(), 4, Image.SizeX, Image.SizeY);
delete FileWriter;
}
// (save output as .astc file):
if (SaveInputOutput)
{
const FString FileName = FString::Printf(TEXT("%s-out.astc"), *DebugDumpFileNameBase );
FArchive* FileWriter = IFileManager::Get().CreateFileWriter(*FileName);
SaveImageAsASTC(*FileWriter, OutCompressedImage.RawData.GetData(), OutCompressedImage.SizeX, OutCompressedImage.SizeY, EncoderSettings.block_width, EncoderSettings.block_height);
delete FileWriter;
}
#endif
}
}
OutCompressedImage.PixelFormat = CompressedPixelFormat;
OutCompressedImage.SizeX = InImage.SizeX;
OutCompressedImage.SizeY = InImage.SizeY;
OutCompressedImage.NumSlicesWithDepth = InImage.NumSlices;
return bCompressionSucceeded;
}
};
/**
* Module for DXT texture compression.
*/
static ITextureFormat* Singleton = nullptr;
class FTextureFormatIntelISPCTexCompModule : public ITextureFormatModule
{
public:
FTextureFormatIntelISPCTexCompModule()
{
}
virtual ~FTextureFormatIntelISPCTexCompModule()
{
if ( Singleton )
{
delete Singleton;
Singleton = nullptr;
}
}
virtual bool CanCallGetTextureFormats() override { return false; }
virtual ITextureFormat* GetTextureFormat()
{
if (!Singleton)
{
Singleton = new FTextureFormatIntelISPCTexComp();
}
return Singleton;
}
static inline UE::DerivedData::TBuildFunctionFactory<FIntelISPCTexCompTextureBuildFunction> BuildFunctionFactory;
};
IMPLEMENT_MODULE(FTextureFormatIntelISPCTexCompModule, TextureFormatIntelISPCTexComp);
Reference in New Issue View Git Blame Copy Permalink