/**
* Executes all pending shadow-map encoding requests.
* @param InWorld World in which the textures exist
* @param bLightingSuccessful Whether the lighting build was successful or not.
*/
void FShadowMap2D::EncodeTextures(UWorld* InWorld , bool bLightingSuccessful )
{
if ( bLightingSuccessful )
{
GWarn->BeginSlowTask( NSLOCTEXT("ShadowMap2D", "BeginEncodingShadowMapsTask", "Encoding shadow-maps"), false );
const int32 PackedLightAndShadowMapTextureSize = InWorld->GetWorldSettings()->PackedLightAndShadowMapTextureSize;
// Reset the pending shadow-map size.
PendingShadowMapSize = 0;
Sort(PendingShadowMaps.GetData(), PendingShadowMaps.Num(), FCompareShadowMaps());
// Allocate texture space for each light-map.
TIndirectArray<FShadowMapPendingTexture> PendingTextures;
for(int32 ShadowMapIndex = 0;ShadowMapIndex < PendingShadowMaps.Num();ShadowMapIndex++)
{
FShadowMapAllocation& Allocation = PendingShadowMaps[ShadowMapIndex];
// Find an existing texture which the light-map can be stored in.
FShadowMapPendingTexture* Texture = NULL;
for(int32 TextureIndex = 0;TextureIndex < PendingTextures.Num();TextureIndex++)
{
FShadowMapPendingTexture& ExistingTexture = PendingTextures[TextureIndex];
// See if the new one will fit in the existing texture
if ( ExistingTexture.AddElement( Allocation ) )
{
Texture = &ExistingTexture;
break;
}
}
// If there is no appropriate texture, create a new one.
if(!Texture)
{
int32 NewTextureSizeX = PackedLightAndShadowMapTextureSize;
int32 NewTextureSizeY = PackedLightAndShadowMapTextureSize;
if(Allocation.MappedRect.Width() > NewTextureSizeX || Allocation.MappedRect.Height() > NewTextureSizeY)
{
NewTextureSizeX = FMath::RoundUpToPowerOfTwo(Allocation.MappedRect.Width());
NewTextureSizeY = FMath::RoundUpToPowerOfTwo(Allocation.MappedRect.Height());
}
// If there is no existing appropriate texture, create a new one.
Texture = ::new(PendingTextures) FShadowMapPendingTexture(NewTextureSizeX,NewTextureSizeY);
Texture->Outer = Allocation.TextureOuter;
Texture->Bounds = Allocation.Bounds;
Texture->ShadowmapFlags = Allocation.ShadowmapFlags;
verify( Texture->AddElement( Allocation, true ) );
}
}
for(int32 TextureIndex = 0;TextureIndex < PendingTextures.Num();TextureIndex++)
{
if (bUpdateStatus && (TextureIndex % 20) == 0)
{
GWarn->UpdateProgress(TextureIndex, PendingTextures.Num());
}
FShadowMapPendingTexture& PendingTexture = PendingTextures[TextureIndex];
PendingTexture.StartEncoding(InWorld);
}
PendingTextures.Empty();
PendingShadowMaps.Empty();
GWarn->EndSlowTask();
}
else
{
PendingShadowMaps.Empty();
}
}
void FShadowMap2D::EncodeSingleTexture(FShadowMapPendingTexture& PendingTexture, UShadowMapTexture2D* Texture, TArray< TArray<FFourDistanceFieldSamples> >& MipData)
{
TArray<FFourDistanceFieldSamples>* TopMipData = new(MipData) TArray<FFourDistanceFieldSamples>();
TopMipData->Empty(PendingTexture.GetSizeX() * PendingTexture.GetSizeY());
TopMipData->AddZeroed(PendingTexture.GetSizeX() * PendingTexture.GetSizeY());
int32 TextureSizeX = Texture->Source.GetSizeX();
int32 TextureSizeY = Texture->Source.GetSizeY();
for (int32 AllocationIndex = 0;AllocationIndex < PendingTexture.Allocations.Num();AllocationIndex++)
{
FShadowMapAllocation& Allocation = *PendingTexture.Allocations[AllocationIndex];
bool bChannelUsed[4] = {0};
for (int32 ChannelIndex = 0; ChannelIndex < 4; ChannelIndex++)
{
for (TMap<ULightComponent*, TArray<FQuantizedSignedDistanceFieldShadowSample>>::TIterator It(Allocation.ShadowMapData); It; ++It)
{
if (It.Key()->ShadowMapChannel == ChannelIndex)
{
bChannelUsed[ChannelIndex] = true;
const TArray<FQuantizedSignedDistanceFieldShadowSample>& SourceSamples = It.Value();
// Copy the raw data for this light-map into the raw texture data array.
for (int32 Y = Allocation.MappedRect.Min.Y; Y < Allocation.MappedRect.Max.Y; ++Y)
{
for (int32 X = Allocation.MappedRect.Min.X; X < Allocation.MappedRect.Max.X; ++X)
{
int32 DestY = Y - Allocation.MappedRect.Min.Y + Allocation.OffsetY;
int32 DestX = X - Allocation.MappedRect.Min.X + Allocation.OffsetX;
FFourDistanceFieldSamples& DestSample = (*TopMipData)[DestY * TextureSizeX + DestX];
const FQuantizedSignedDistanceFieldShadowSample& SourceSample = SourceSamples[Y * Allocation.TotalSizeX + X];
if ( SourceSample.Coverage > 0 )
{
DestSample.Samples[ChannelIndex] = SourceSample;
}
#if WITH_EDITOR
if ( SourceSample.Coverage > 0 )
{
GNumShadowmapMappedTexels++;
}
else
{
GNumShadowmapUnmappedTexels++;
}
#endif
}
}
}
}
}
// Link the shadow-map to the texture.
Allocation.ShadowMap->Texture = Texture;
// Free the shadow-map's raw data.
for (TMap<ULightComponent*, TArray<FQuantizedSignedDistanceFieldShadowSample> >::TIterator It(Allocation.ShadowMapData); It; ++It)
{
It.Value().Empty();
}
int32 PaddedSizeX = Allocation.TotalSizeX;
int32 PaddedSizeY = Allocation.TotalSizeY;
int32 BaseX = Allocation.OffsetX - Allocation.MappedRect.Min.X;
int32 BaseY = Allocation.OffsetY - Allocation.MappedRect.Min.Y;
#if WITH_EDITOR
if (GLightmassDebugOptions.bPadMappings && (Allocation.PaddingType == LMPT_NormalPadding))
{
if ((PaddedSizeX - 2 > 0) && ((PaddedSizeY - 2) > 0))
{
PaddedSizeX -= 2;
PaddedSizeY -= 2;
BaseX += 1;
BaseY += 1;
}
}
#endif
// Calculate the coordinate scale/biases for each shadow-map stored in the texture.
Allocation.ShadowMap->CoordinateScale = FVector2D(
(float)PaddedSizeX / (float)PendingTexture.GetSizeX(),
(float)PaddedSizeY / (float)PendingTexture.GetSizeY()
);
Allocation.ShadowMap->CoordinateBias = FVector2D(
(float)BaseX / (float)PendingTexture.GetSizeX(),
(float)BaseY / (float)PendingTexture.GetSizeY()
);
for (int32 ChannelIndex = 0; ChannelIndex < 4; ChannelIndex++)
{
Allocation.ShadowMap->bChannelValid[ChannelIndex] = bChannelUsed[ChannelIndex];
}
}
const uint32 NumMips = FMath::Max(FMath::CeilLogTwo(TextureSizeX),FMath::CeilLogTwo(TextureSizeY)) + 1;
for (uint32 MipIndex = 1;MipIndex < NumMips;MipIndex++)
{
const uint32 SourceMipSizeX = FMath::Max(1, TextureSizeX >> (MipIndex - 1));
const uint32 SourceMipSizeY = FMath::Max(1, TextureSizeY >> (MipIndex - 1));
const uint32 DestMipSizeX = FMath::Max(1, TextureSizeX >> MipIndex);
const uint32 DestMipSizeY = FMath::Max(1, TextureSizeY >> MipIndex);
// Downsample the previous mip-level, taking into account which texels are mapped.
TArray<FFourDistanceFieldSamples>* NextMipData = new(MipData) TArray<FFourDistanceFieldSamples>();
NextMipData->Empty(DestMipSizeX * DestMipSizeY);
NextMipData->AddZeroed(DestMipSizeX * DestMipSizeY);
const uint32 MipFactorX = SourceMipSizeX / DestMipSizeX;
const uint32 MipFactorY = SourceMipSizeY / DestMipSizeY;
for (uint32 Y = 0;Y < DestMipSizeY;Y++)
{
for (uint32 X = 0;X < DestMipSizeX;X++)
{
float AccumulatedFilterableComponents[4][FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents];
for (int32 ChannelIndex = 0; ChannelIndex < 4; ChannelIndex++)
{
for (int32 i = 0; i < FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents; i++)
{
AccumulatedFilterableComponents[ChannelIndex][i] = 0;
}
}
uint32 Coverage[4] = {0};
for (uint32 SourceY = Y * MipFactorY;SourceY < (Y + 1) * MipFactorY;SourceY++)
{
for (uint32 SourceX = X * MipFactorX;SourceX < (X + 1) * MipFactorX;SourceX++)
{
for (int32 ChannelIndex = 0; ChannelIndex < 4; ChannelIndex++)
{
const FFourDistanceFieldSamples& FourSourceSamples = MipData[MipIndex - 1][SourceY * SourceMipSizeX + SourceX];
const FQuantizedSignedDistanceFieldShadowSample& SourceSample = FourSourceSamples.Samples[ChannelIndex];
if (SourceSample.Coverage)
{
for (int32 i = 0; i < FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents; i++)
{
AccumulatedFilterableComponents[ChannelIndex][i] += SourceSample.GetFilterableComponent(i) * SourceSample.Coverage;
}
Coverage[ChannelIndex] += SourceSample.Coverage;
}
}
}
}
FFourDistanceFieldSamples& FourDestSamples = (*NextMipData)[Y * DestMipSizeX + X];
for (int32 ChannelIndex = 0; ChannelIndex < 4; ChannelIndex++)
{
FQuantizedSignedDistanceFieldShadowSample& DestSample = FourDestSamples.Samples[ChannelIndex];
if (Coverage[ChannelIndex])
{
for (int32 i = 0; i < FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents; i++)
{
DestSample.SetFilterableComponent(AccumulatedFilterableComponents[ChannelIndex][i] / (float)Coverage[ChannelIndex], i);
}
DestSample.Coverage = (uint8)(Coverage[ChannelIndex] / (MipFactorX * MipFactorY));
}
else
{
for (int32 i = 0; i < FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents; i++)
{
AccumulatedFilterableComponents[ChannelIndex][i] = 0;
}
DestSample.Coverage = 0;
}
}
}
}
}
const FIntPoint Neighbors[] =
{
// Check immediate neighbors first
FIntPoint(1,0),
FIntPoint(0,1),
FIntPoint(-1,0),
FIntPoint(0,-1),
// Check diagonal neighbors if no immediate neighbors are found
FIntPoint(1,1),
FIntPoint(-1,1),
FIntPoint(-1,-1),
FIntPoint(1,-1)
};
// Extrapolate texels which are mapped onto adjacent texels which are not mapped to avoid artifacts when using texture filtering.
for (int32 MipIndex = 0;MipIndex < MipData.Num();MipIndex++)
{
uint32 MipSizeX = FMath::Max(1,TextureSizeX >> MipIndex);
uint32 MipSizeY = FMath::Max(1,TextureSizeY >> MipIndex);
for (uint32 DestY = 0;DestY < MipSizeY;DestY++)
{
for (uint32 DestX = 0;DestX < MipSizeX;DestX++)
{
FFourDistanceFieldSamples& FourDestSamples = MipData[MipIndex][DestY * MipSizeX + DestX];
for (int32 ChannelIndex = 0; ChannelIndex < 4; ChannelIndex++)
{
FQuantizedSignedDistanceFieldShadowSample& DestSample = FourDestSamples.Samples[ChannelIndex];
if (DestSample.Coverage == 0)
{
float ExtrapolatedFilterableComponents[FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents];
for (int32 i = 0; i < FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents; i++)
{
ExtrapolatedFilterableComponents[i] = 0;
}
for (int32 NeighborIndex = 0; NeighborIndex < ARRAY_COUNT(Neighbors); NeighborIndex++)
{
if (DestY + Neighbors[NeighborIndex].Y >= 0
&& DestY + Neighbors[NeighborIndex].Y < MipSizeY
&& DestX + Neighbors[NeighborIndex].X >= 0
&& DestX + Neighbors[NeighborIndex].X < MipSizeX)
{
const FFourDistanceFieldSamples& FourNeighborSamples = MipData[MipIndex][(DestY + Neighbors[NeighborIndex].Y) * MipSizeX + DestX + Neighbors[NeighborIndex].X];
const FQuantizedSignedDistanceFieldShadowSample& NeighborSample = FourNeighborSamples.Samples[ChannelIndex];
if (NeighborSample.Coverage > 0)
{
if (DestY + Neighbors[NeighborIndex].Y * 2 >= 0
&& DestY + Neighbors[NeighborIndex].Y * 2 < MipSizeY
&& DestX + Neighbors[NeighborIndex].X * 2 >= 0
&& DestX + Neighbors[NeighborIndex].X * 2 < MipSizeX)
{
// Lookup the second neighbor in the first neighbor's direction
//@todo - check the second neighbor's coverage?
const FFourDistanceFieldSamples& SecondFourNeighborSamples = MipData[MipIndex][(DestY + Neighbors[NeighborIndex].Y * 2) * MipSizeX + DestX + Neighbors[NeighborIndex].X * 2];
const FQuantizedSignedDistanceFieldShadowSample& SecondNeighborSample = FourNeighborSamples.Samples[ChannelIndex];
for (int32 i = 0; i < FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents; i++)
{
// Extrapolate while maintaining the first derivative, which is especially important for signed distance fields
ExtrapolatedFilterableComponents[i] = NeighborSample.GetFilterableComponent(i) * 2.0f - SecondNeighborSample.GetFilterableComponent(i);
}
}
else
{
// Couldn't find a second neighbor to use for extrapolating, just copy the neighbor's values
for (int32 i = 0; i < FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents; i++)
{
ExtrapolatedFilterableComponents[i] = NeighborSample.GetFilterableComponent(i);
}
}
break;
}
}
}
for (int32 i = 0; i < FQuantizedSignedDistanceFieldShadowSample::NumFilterableComponents; i++)
{
DestSample.SetFilterableComponent(ExtrapolatedFilterableComponents[i], i);
}
}
}
}
}
}
}
/**
* Executes all pending shadow-map encoding requests.
* @param InWorld World in which the textures exist
* @param bLightingSuccessful Whether the lighting build was successful or not.
*/
void FShadowMap2D::EncodeTextures(UWorld* InWorld , bool bLightingSuccessful)
{
if ( bLightingSuccessful )
{
GWarn->BeginSlowTask( NSLOCTEXT("ShadowMap2D", "BeginEncodingShadowMapsTask", "Encoding shadow-maps"), false );
const int32 PackedLightAndShadowMapTextureSize = InWorld->GetWorldSettings()->PackedLightAndShadowMapTextureSize;
// Reset the pending shadow-map size.
PendingShadowMapSize = 0;
Sort(PendingShadowMaps.GetData(), PendingShadowMaps.Num(), FCompareShadowMaps());
// Allocate texture space for each shadow-map.
TIndirectArray<FShadowMapPendingTexture> PendingTextures;
for (FShadowMapAllocationGroup& PendingGroup : PendingShadowMaps)
{
if (!ensure(PendingGroup.Allocations.Num() >= 1))
{
continue;
}
int32 MaxWidth = 0;
int32 MaxHeight = 0;
for (auto& Allocation : PendingGroup.Allocations)
{
MaxWidth = FMath::Max(MaxWidth, Allocation->MappedRect.Width());
MaxHeight = FMath::Max(MaxHeight, Allocation->MappedRect.Height());
}
FShadowMapPendingTexture* Texture = nullptr;
// Find an existing texture which the shadow-map can be stored in.
// Shadowmaps will always be 4-pixel aligned...
for (FShadowMapPendingTexture& ExistingTexture : PendingTextures)
{
if (ExistingTexture.AddElement(PendingGroup))
{
Texture = &ExistingTexture;
break;
}
}
if (!Texture)
{
int32 NewTextureSizeX = PackedLightAndShadowMapTextureSize;
int32 NewTextureSizeY = PackedLightAndShadowMapTextureSize;
// Assumes identically-sized allocations, fit into the smallest square
const int32 AllocationCountX = FMath::CeilToInt(FMath::Sqrt(FMath::DivideAndRoundUp(PendingGroup.Allocations.Num() * MaxHeight, MaxWidth)));
const int32 AllocationCountY = FMath::DivideAndRoundUp(PendingGroup.Allocations.Num(), AllocationCountX);
const int32 AllocationSizeX = AllocationCountX * MaxWidth;
const int32 AllocationSizeY = AllocationCountY * MaxHeight;
if (AllocationSizeX > NewTextureSizeX || AllocationSizeY > NewTextureSizeY)
{
NewTextureSizeX = FMath::RoundUpToPowerOfTwo(AllocationSizeX);
NewTextureSizeY = FMath::RoundUpToPowerOfTwo(AllocationSizeY);
}
// If there is no existing appropriate texture, create a new one.
Texture = new FShadowMapPendingTexture(NewTextureSizeX, NewTextureSizeY);
PendingTextures.Add(Texture);
Texture->Outer = PendingGroup.TextureOuter;
Texture->Bounds = PendingGroup.Bounds;
Texture->ShadowmapFlags = PendingGroup.ShadowmapFlags;
verify(Texture->AddElement(PendingGroup));
}
// Give the texture ownership of the allocations
for (auto& Allocation : PendingGroup.Allocations)
{
Texture->Allocations.Add(Allocation.Release());
}
}
PendingShadowMaps.Empty();
// Encode all the pending textures.
for (int32 TextureIndex = 0; TextureIndex < PendingTextures.Num(); TextureIndex++)
{
if (bUpdateStatus && (TextureIndex % 20) == 0)
{
GWarn->UpdateProgress(TextureIndex, PendingTextures.Num());
}
FShadowMapPendingTexture& PendingTexture = PendingTextures[TextureIndex];
PendingTexture.StartEncoding(InWorld);
}
PendingTextures.Empty();
GWarn->EndSlowTask();
}
else
{
PendingShadowMaps.Empty();
}
}
