// Copyright Epic Games, Inc. All Rights Reserved.

/*=============================================================================
	ImportVolumetricLightmap.h
=============================================================================*/

#include "Lightmass/Lightmass.h"
#include "EngineDefines.h"
#include "Engine/World.h"
#include "EngineUtils.h"
#include "PrecomputedVolumetricLightmap.h"
#include "Engine/MapBuildDataRegistry.h"
#include "ImportExport.h"
#include "UnrealEngine.h"
#include "Logging/TokenizedMessage.h"
#include "Logging/MessageLog.h"
#include "RenderUtils.h"
#include "WorldPartition/StaticLightingData/VolumetricLightmapGrid.h"

#define LOCTEXT_NAMESPACE "ImportVolumetricLightmap"

DEFINE_LOG_CATEGORY_STATIC(LogVolumetricLightmapImport, Log, All);

FVector GDebugVoxelPosition = FVector::ZeroVector;

void CopyBrickToAtlasVolumeTexture(int32 FormatSize, FIntVector AtlasSize, FIntVector BrickMin, FIntVector BrickSize, const uint8* RESTRICT SourceData, uint8* RESTRICT DestData)
{
	const int32 SourcePitch = BrickSize.X * FormatSize;
	const int32 Pitch = AtlasSize.X * FormatSize;
	const int32 DepthPitch = AtlasSize.X * AtlasSize.Y * FormatSize;

	// Copy each row into the correct position in the global volume texture
	for (int32 ZIndex = 0; ZIndex < BrickSize.Z; ZIndex++)
	{
		const int32 DestZIndex = (BrickMin.Z + ZIndex) * DepthPitch + BrickMin.X * FormatSize;
		const int32 SourceZIndex = ZIndex * BrickSize.Y * SourcePitch;

		for (int32 YIndex = 0; YIndex < BrickSize.Y; YIndex++)
		{
			const int32 DestIndex = DestZIndex + (BrickMin.Y + YIndex) * Pitch;
			const int32 SourceIndex = SourceZIndex + YIndex * SourcePitch;
			FMemory::Memcpy((uint8*)&DestData[DestIndex], (const uint8*)&SourceData[SourceIndex], SourcePitch);
		}
	}
}

void CopyBetweenAtlasVolumeTextures(
	int32 FormatSize,
	FIntVector BrickSize,
	FIntVector SourceAtlasSize,
	FIntVector SourceBrickMin,
	const TArray<uint8>& SourceData,
	FIntVector DestAtlasSize,
	FIntVector DestBrickMin,
	TArray<uint8>& DestData)
{
	const int32 DestPitch = DestAtlasSize.X * FormatSize;
	const int32 DestDepthPitch = DestAtlasSize.X * DestAtlasSize.Y * FormatSize;
	const int32 SourcePitch = SourceAtlasSize.X * FormatSize;
	const int32 SourceDepthPitch = SourceAtlasSize.X * SourceAtlasSize.Y * FormatSize;

	// Copy each row into the correct position in the global volume texture
	for (int32 ZIndex = 0; ZIndex < BrickSize.Z; ZIndex++)
	{
		const int32 DestZIndex = (DestBrickMin.Z + ZIndex) * DestDepthPitch + DestBrickMin.X * FormatSize;
		const int32 SourceZIndex = (SourceBrickMin.Z + ZIndex) * SourceDepthPitch + SourceBrickMin.X * FormatSize;

		for (int32 YIndex = 0; YIndex < BrickSize.Y; YIndex++)
		{
			const int32 DestIndex = DestZIndex + (DestBrickMin.Y + YIndex) * DestPitch;
			const int32 SourceIndex = SourceZIndex + (SourceBrickMin.Y + YIndex) * SourcePitch;
			FMemory::Memcpy((uint8*)&DestData[DestIndex], (const uint8*)&SourceData[SourceIndex], BrickSize.X * FormatSize);
		}
	}
}

static int32 ComputeLinearVoxelIndex(FIntVector VoxelCoordinate, FIntVector VolumeDimensions)
{
	return (VoxelCoordinate.Z * VolumeDimensions.Y + VoxelCoordinate.Y) * VolumeDimensions.X + VoxelCoordinate.X;
}

struct FImportedVolumetricLightmapBrick
{
	FGuid IntersectingLevelGuid;
	FIntVector IndirectionTexturePosition;
	int32 TreeDepth;
	float AverageClosestGeometryDistance;
	TArray<FFloat3Packed> AmbientVector;
	TArray<FColor> SHCoefficients[6];
	TArray<FColor> SkyBentNormal;
	TArray<uint8> DirectionalLightShadowing;
	TArray<Lightmass::FIrradianceVoxelImportProcessingData> TaskVoxelImportProcessingData;
};

struct FImportedVolumetricLightmapTaskData
{
	TArray<FImportedVolumetricLightmapBrick> Bricks;
};

inline FIntVector ComputeBrickLayoutPosition(int32 BrickLayoutAllocation, FIntVector BrickLayoutDimensions)
{
	const FIntVector BrickPosition(
		BrickLayoutAllocation % BrickLayoutDimensions.X,
		(BrickLayoutAllocation / BrickLayoutDimensions.X) % BrickLayoutDimensions.Y,
		BrickLayoutAllocation / (BrickLayoutDimensions.X * BrickLayoutDimensions.Y));

	return BrickPosition;
}

bool CopyFromBrickmapTexel(
	FVector IndirectionDataSourceCoordinate,
	FIntVector LocalCellDestCoordinate, 
	int32 MinDestinationNumBottomLevelBricks,
	int32 BrickSize, 
	FIntVector BrickLayoutPosition,
	const FPrecomputedVolumetricLightmapData& CurrentLevelData,
	FVolumetricLightmapBrickData& BrickData)
{
	const FVector IndirectionCoordMax(FVector(CurrentLevelData.IndirectionTextureDimensions) * (1 - GPointFilteringThreshold));

	if (IndirectionDataSourceCoordinate.X < 0 || IndirectionDataSourceCoordinate.Y < 0 || IndirectionDataSourceCoordinate.Z < 0 || 
		IndirectionDataSourceCoordinate.X > IndirectionCoordMax.X || IndirectionDataSourceCoordinate.Y > IndirectionCoordMax.Y || IndirectionDataSourceCoordinate.Z > IndirectionCoordMax.Z)
	{
		return false;
	}

	FIntVector IndirectionBrickOffset;
	int32 IndirectionBrickSize;

	checkSlow(GPixelFormats[CurrentLevelData.IndirectionTexture.Format].BlockBytes == sizeof(uint8) * 4);
	SampleIndirectionTexture(IndirectionDataSourceCoordinate, CurrentLevelData.IndirectionTextureDimensions, CurrentLevelData.IndirectionTexture.Data.GetData(), IndirectionBrickOffset, IndirectionBrickSize);

	if (IndirectionBrickSize > MinDestinationNumBottomLevelBricks)
	{
		const FVector BrickTextureCoordinate = ComputeBrickTextureCoordinate(IndirectionDataSourceCoordinate, IndirectionBrickOffset, IndirectionBrickSize, BrickSize);

		const FIntVector DestCellPosition = BrickLayoutPosition + LocalCellDestCoordinate;
		const int32 LinearDestCellIndex = ComputeLinearVoxelIndex(DestCellPosition, CurrentLevelData.BrickDataDimensions);

		*(FFloat3Packed*)&BrickData.AmbientVector.Data[LinearDestCellIndex * sizeof(FFloat3Packed)] = FilteredVolumeLookupReconverted<FFloat3Packed>(BrickTextureCoordinate, CurrentLevelData.BrickDataDimensions, (const FFloat3Packed*)BrickData.AmbientVector.Data.GetData());
		
		for (int32 i = 0; i < UE_ARRAY_COUNT(BrickData.SHCoefficients); i++)
		{
			*(FColor*)&BrickData.SHCoefficients[i].Data[LinearDestCellIndex * sizeof(FColor)] = FilteredVolumeLookupReconverted<FColor>(BrickTextureCoordinate, CurrentLevelData.BrickDataDimensions, (const FColor*)BrickData.SHCoefficients[i].Data.GetData());
		}

		if (BrickData.SkyBentNormal.Data.Num() > 0)
		{
			*(FColor*)&BrickData.SkyBentNormal.Data[LinearDestCellIndex * sizeof(FColor)] = FilteredVolumeLookupReconverted<FColor>(BrickTextureCoordinate, CurrentLevelData.BrickDataDimensions, (const FColor*)BrickData.SkyBentNormal.Data.GetData());
		}
	
		*(uint8*)&BrickData.DirectionalLightShadowing.Data[LinearDestCellIndex * sizeof(uint8)] = FilteredVolumeLookupReconverted<uint8>(BrickTextureCoordinate, CurrentLevelData.BrickDataDimensions, (const uint8*)BrickData.DirectionalLightShadowing.Data.GetData());

		return true;
	}

	return false;
}

static NSwarm::TChannelFlags LM_VOLUMETRICLIGHTMAP_CHANNEL_FLAGS = NSwarm::SWARM_JOB_CHANNEL_READ;

void FLightmassProcessor::ImportIrradianceTasks(bool& bGenerateSkyShadowing, TArray<FImportedVolumetricLightmapTaskData>& TaskDataArray)
{
	TList<FGuid>* Element = CompletedVolumetricLightmapTasks.ExtractAll();

	while (Element)
	{
		// If this task has not already been imported, import it now
		TList<FGuid>* NextElement = Element->Next;

		const FString ChannelName = Lightmass::CreateChannelName(Element->Element, Lightmass::LM_VOLUMETRICLIGHTMAP_VERSION, Lightmass::LM_VOLUMETRICLIGHTMAP_EXTENSION);
		const int32 Channel = Swarm.OpenChannel( *ChannelName, LM_VOLUMETRICLIGHTMAP_CHANNEL_FLAGS );
		if (Channel >= 0)
		{
			TaskDataArray.AddDefaulted();
			FImportedVolumetricLightmapTaskData& NewTaskData = TaskDataArray.Last();

			int32 NumBricks;
			Swarm.ReadChannel(Channel, &NumBricks, sizeof(NumBricks));
			NewTaskData.Bricks.Empty(NumBricks);

			for (int32 BrickIndex = 0; BrickIndex < NumBricks; BrickIndex++)
			{
				NewTaskData.Bricks.AddDefaulted();
				FImportedVolumetricLightmapBrick& NewBrick = NewTaskData.Bricks.Last();
				Swarm.ReadChannel(Channel, &NewBrick.IntersectingLevelGuid, sizeof(NewBrick.IntersectingLevelGuid));
				Swarm.ReadChannel(Channel, &NewBrick.IndirectionTexturePosition, sizeof(NewBrick.IndirectionTexturePosition));
				Swarm.ReadChannel(Channel, &NewBrick.TreeDepth, sizeof(NewBrick.TreeDepth));
				Swarm.ReadChannel(Channel, &NewBrick.AverageClosestGeometryDistance, sizeof(NewBrick.AverageClosestGeometryDistance));
				ReadArray(Channel, NewBrick.AmbientVector);

				for (int32 i = 0; i < UE_ARRAY_COUNT(NewBrick.SHCoefficients); i++)
				{
					ReadArray(Channel, NewBrick.SHCoefficients[i]);
				}

				ReadArray(Channel, NewBrick.SkyBentNormal);
				ReadArray(Channel, NewBrick.DirectionalLightShadowing);

				bGenerateSkyShadowing = bGenerateSkyShadowing || NewBrick.SkyBentNormal.Num() > 0;

				ReadArray(Channel, NewBrick.TaskVoxelImportProcessingData);
			}

			ImportDebugOutputStruct(Channel);

			Swarm.CloseChannel(Channel);
		}
		else
		{
			UE_LOG(LogVolumetricLightmapImport, Fatal,  TEXT("Error, failed to import volumetric lightmap %s with error code %d"), *ChannelName, Channel );
		}

		delete Element;
		Element = NextElement;
	}
}

// One pass needed to cover the trilinear filtering footprint, another pass needed to cover exterior voxels which see backfaces due to the large ray start bias.
int32 NumDilateOverEmbeddedVoxelsPasses = 2;

struct FFilteredBrickData
{
	FFloat3Packed AmbientVector;
	FColor SHCoefficients[UE_ARRAY_COUNT(FImportedVolumetricLightmapBrick::SHCoefficients)];
	uint8 DirectionalLightShadowing;
};

void FilterWithNeighbors(
	const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth,
	int32 BrickStartAllocation,
	int32 CurrentDepth,
	FIntVector BrickLayoutDimensions,
	const Lightmass::FVolumetricLightmapSettings& VolumetricLightmapSettings,
	FPrecomputedVolumetricLightmapData& CurrentLevelData,
	const TArray<Lightmass::FIrradianceVoxelImportProcessingData>& VoxelImportProcessingData,
	TArray<Lightmass::FIrradianceVoxelImportProcessingData>& NewVoxelImportProcessingData)
{
	int32 BrickSize = VolumetricLightmapSettings.BrickSize;
	int32 PaddedBrickSize = BrickSize + 1;
	const int32 BrickSizeLog2 = FMath::FloorLog2(BrickSize);
	const float InvBrickSize = 1.0f / BrickSize;

	const FBox VolumeBox(VolumetricLightmapSettings.VolumeMin, VolumetricLightmapSettings.VolumeMin + VolumetricLightmapSettings.VolumeSize);
	const FVector DebugPositionIndirectionCoordinate = ComputeIndirectionCoordinate(GDebugVoxelPosition, VolumeBox, CurrentLevelData.IndirectionTextureDimensions);

	TArray<FFilteredBrickData> FilteredBrickData;
	TArray<bool> FilteredBrickDataValid;

	FilteredBrickData.Empty(BrickSize * BrickSize * BrickSize);
	FilteredBrickData.AddZeroed(BrickSize * BrickSize * BrickSize);
	FilteredBrickDataValid.Empty(BrickSize * BrickSize * BrickSize);
	FilteredBrickDataValid.AddZeroed(BrickSize * BrickSize * BrickSize);

	// Fill in voxels which are inside geometry with their valid neighbors
	for (int32 BrickIndex = 0; BrickIndex < BricksAtCurrentDepth.Num(); BrickIndex++)
	{
		const FImportedVolumetricLightmapBrick& Brick = *BricksAtCurrentDepth[BrickIndex];

		// Initialize temporary brick data to invalid
		FPlatformMemory::Memzero(FilteredBrickDataValid.GetData(), FilteredBrickDataValid.Num() * FilteredBrickDataValid.GetTypeSize());

		checkSlow(Brick.TreeDepth == CurrentDepth);

		const int32 DetailCellsPerCurrentLevelBrick = 1 << ((VolumetricLightmapSettings.MaxRefinementLevels - Brick.TreeDepth) * BrickSizeLog2);
		const int32 NumBottomLevelBricks = DetailCellsPerCurrentLevelBrick / BrickSize;
		const FVector IndirectionTexturePosition = FVector(Brick.IndirectionTexturePosition);
		const FIntVector BrickLayoutPosition = ComputeBrickLayoutPosition(BrickStartAllocation + BrickIndex, BrickLayoutDimensions) * PaddedBrickSize;

		for (int32 Z = 0; Z < BrickSize; Z++)
		{
			for (int32 Y = 0; Y < BrickSize; Y++)
			{
				for (int32 X = 0; X < BrickSize; X++)
				{
					FIntVector VoxelCoordinate(X, Y, Z);

					const int32 LinearDestCellIndex = ComputeLinearVoxelIndex(VoxelCoordinate + BrickLayoutPosition, CurrentLevelData.BrickDataDimensions);
					Lightmass::FIrradianceVoxelImportProcessingData VoxelImportData = VoxelImportProcessingData[LinearDestCellIndex];

					if (GDebugVoxelPosition != FVector::ZeroVector)
					{
						const FVector CellIndirectionTexturePosition = IndirectionTexturePosition + FVector(X, Y, Z) * InvBrickSize * NumBottomLevelBricks;
						const FBox CellIndirectionTextureBounds(CellIndirectionTexturePosition, CellIndirectionTexturePosition + InvBrickSize * NumBottomLevelBricks);

						if (CellIndirectionTextureBounds.IsInside(DebugPositionIndirectionCoordinate))
						{
							int32 DebugBreakpoint = 0;
						}
					}

					if (VoxelImportData.bInsideGeometry
						// Don't modify border voxels
						&& !VoxelImportData.bBorderVoxel)
					{
						//@todo - filter SkyBentNormal from neighbors too
						FLinearColor AmbientVector = FLinearColor(0, 0, 0, 0);
						FLinearColor SHCoefficients[UE_ARRAY_COUNT(Brick.SHCoefficients)];
						FLinearColor DirectionalLightShadowing = FLinearColor(0, 0, 0, 0);

						for (int32 i = 0; i < UE_ARRAY_COUNT(SHCoefficients); i++)
						{
							SHCoefficients[i] = FLinearColor(0, 0, 0, 0);
						}
	
						float TotalWeight = 0.0f;

						for (int32 NeighborZ = -1; NeighborZ <= 1; NeighborZ++)
						{
							for (int32 NeighborY = -1; NeighborY <= 1; NeighborY++)
							{
								for (int32 NeighborX = -1; NeighborX <= 1; NeighborX++)
								{
									const FVector NeighborIndirectionDataSourceCoordinate = IndirectionTexturePosition + FVector(X + NeighborX, Y + NeighborY, Z + NeighborZ) * InvBrickSize * NumBottomLevelBricks;
									const FIntVector NeighborVoxelCoordinate(X + NeighborX, Y + NeighborY, Z + NeighborZ);

									if (NeighborVoxelCoordinate != VoxelCoordinate
										&& NeighborIndirectionDataSourceCoordinate.X >= 0.0f 
										&& NeighborIndirectionDataSourceCoordinate.Y >= 0.0f 
										&& NeighborIndirectionDataSourceCoordinate.Z >= 0.0f
										&& NeighborIndirectionDataSourceCoordinate.X < CurrentLevelData.IndirectionTextureDimensions.X 
										&& NeighborIndirectionDataSourceCoordinate.Y < CurrentLevelData.IndirectionTextureDimensions.Y 
										&& NeighborIndirectionDataSourceCoordinate.Z < CurrentLevelData.IndirectionTextureDimensions.Z)
									{
										FIntVector IndirectionBrickOffset;
										int32 IndirectionBrickSize;

										checkSlow(GPixelFormats[CurrentLevelData.IndirectionTexture.Format].BlockBytes == sizeof(uint8) * 4);
										SampleIndirectionTexture(NeighborIndirectionDataSourceCoordinate, CurrentLevelData.IndirectionTextureDimensions, CurrentLevelData.IndirectionTexture.Data.GetData(), IndirectionBrickOffset, IndirectionBrickSize);

										// Only filter from bricks with equal density, to avoid reading from uninitialized padding
										// This causes seams but they fall at density transitions so not noticeable
										if (IndirectionBrickSize == NumBottomLevelBricks)
										{
											const FVector BrickTextureCoordinate = ComputeBrickTextureCoordinate(NeighborIndirectionDataSourceCoordinate, IndirectionBrickOffset, IndirectionBrickSize, BrickSize);
											Lightmass::FIrradianceVoxelImportProcessingData NeighborVoxelImportData = NearestVolumeLookup<Lightmass::FIrradianceVoxelImportProcessingData>(BrickTextureCoordinate, CurrentLevelData.BrickDataDimensions, VoxelImportProcessingData.GetData());

											if (!NeighborVoxelImportData.bInsideGeometry && !NeighborVoxelImportData.bBorderVoxel)
											{
												const float NeighborTotal = static_cast<float>(FMath::Abs(NeighborX) + FMath::Abs(NeighborY) + FMath::Abs(NeighborZ));
												const float Weight = 1.0f / FMath::Max<float>(NeighborTotal, .5f);
												FLinearColor NeighborAmbientVector = FilteredVolumeLookup<FFloat3Packed>(BrickTextureCoordinate, CurrentLevelData.BrickDataDimensions, (const FFloat3Packed*)CurrentLevelData.BrickData.AmbientVector.Data.GetData());
												AmbientVector += NeighborAmbientVector * Weight;

												for (int32 i = 0; i < UE_ARRAY_COUNT(SHCoefficients); i++)
												{
													static_assert(UE_ARRAY_COUNT(SHCoefficients) == 6, "Assuming 2 SHCoefficient vectors per color channel");

													// Weight by ambient before filtering, normalized SH coefficients don't filter properly
													float AmbientCoefficient = NeighborAmbientVector.Component(i / 2);
													SHCoefficients[i] += AmbientCoefficient * Weight * FilteredVolumeLookup<FColor>(BrickTextureCoordinate, CurrentLevelData.BrickDataDimensions, (const FColor*)CurrentLevelData.BrickData.SHCoefficients[i].Data.GetData());
												}

												FLinearColor NeighborDirectionalLightShadowing = FilteredVolumeLookup<uint8>(BrickTextureCoordinate, CurrentLevelData.BrickDataDimensions, (const uint8*)CurrentLevelData.BrickData.DirectionalLightShadowing.Data.GetData());
												DirectionalLightShadowing += NeighborDirectionalLightShadowing * Weight;

												TotalWeight += Weight;
											}
										}
									}
								}
							}
						}

						if (TotalWeight > 0.0f)
						{
							const int32 LinearVoxelIndex = ComputeLinearVoxelIndex(VoxelCoordinate, FIntVector(BrickSize, BrickSize, BrickSize));

							// Store filtered output to temporary brick data to avoid order dependent results between voxels
							// This still produces order dependent filtering between neighboring bricks
							FilteredBrickDataValid[LinearVoxelIndex] = true;

							const float InvTotalWeight = 1.0f / TotalWeight;

							const FLinearColor FilteredAmbientColor = AmbientVector * InvTotalWeight;
							FilteredBrickData[LinearVoxelIndex].AmbientVector = ConvertFromLinearColor<FFloat3Packed>(FilteredAmbientColor);

							for (int32 i = 0; i < UE_ARRAY_COUNT(SHCoefficients); i++)
							{
								static_assert(UE_ARRAY_COUNT(SHCoefficients) == 6, "Assuming 2 SHCoefficient vectors per color channel");

								float AmbientCoefficient = FMath::Max(FilteredAmbientColor.Component(i / 2), KINDA_SMALL_NUMBER);

								FilteredBrickData[LinearVoxelIndex].SHCoefficients[i] = ConvertFromLinearColor<FColor>(SHCoefficients[i] * InvTotalWeight / AmbientCoefficient);
							}

							FilteredBrickData[LinearVoxelIndex].DirectionalLightShadowing = ConvertFromLinearColor<uint8>(DirectionalLightShadowing * InvTotalWeight);
						}
					}
				}
			}
		}

		for (int32 Z = 0; Z < BrickSize; Z++)
		{
			for (int32 Y = 0; Y < BrickSize; Y++)
			{
				for (int32 X = 0; X < BrickSize; X++)
				{
					FIntVector VoxelCoordinate(X, Y, Z);
					const int32 LinearVoxelIndex = ComputeLinearVoxelIndex(VoxelCoordinate, FIntVector(BrickSize, BrickSize, BrickSize));

					// Write filtered voxel data back to the original
					if (FilteredBrickDataValid[LinearVoxelIndex])
					{
						const int32 LinearBrickLayoutCellIndex = ComputeLinearVoxelIndex(VoxelCoordinate + BrickLayoutPosition, CurrentLevelData.BrickDataDimensions);

						// Mark as valid for future passes now that we've overwritten with filtered neighbors
						NewVoxelImportProcessingData[LinearBrickLayoutCellIndex].bInsideGeometry = false;

						FFloat3Packed* DestAmbientVector = (FFloat3Packed*)&CurrentLevelData.BrickData.AmbientVector.Data[LinearBrickLayoutCellIndex * sizeof(FFloat3Packed)];
						*DestAmbientVector = FilteredBrickData[LinearVoxelIndex].AmbientVector;

						for (int32 i = 0; i < UE_ARRAY_COUNT(FilteredBrickData[LinearVoxelIndex].SHCoefficients); i++)
						{
							FColor* DestCoefficients = (FColor*)&CurrentLevelData.BrickData.SHCoefficients[i].Data[LinearBrickLayoutCellIndex * sizeof(FColor)];
							*DestCoefficients = FilteredBrickData[LinearVoxelIndex].SHCoefficients[i];
						}

						uint8* DestDirectionalLightShadowing = (uint8*)&CurrentLevelData.BrickData.DirectionalLightShadowing.Data[LinearBrickLayoutCellIndex * sizeof(uint8)];
						*DestDirectionalLightShadowing = FilteredBrickData[LinearVoxelIndex].DirectionalLightShadowing;
					}
				}
			}
		}
	}
}

void StitchDetailBricksWithLowDensityNeighbors(
	const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth,
	int32 BrickStartAllocation,
	int32 CurrentDepth,
	FIntVector BrickLayoutDimensions,
	const Lightmass::FVolumetricLightmapSettings& VolumetricLightmapSettings,
	FPrecomputedVolumetricLightmapData& CurrentLevelData)
{
	int32 BrickSize = VolumetricLightmapSettings.BrickSize;
	int32 PaddedBrickSize = BrickSize + 1;
	const int32 BrickSizeLog2 = FMath::FloorLog2(BrickSize);
	const float InvBrickSize = 1.0f / BrickSize;

	// Stitch all higher density bricks with neighboring lower density bricks
	for (int32 BrickIndex = 0; BrickIndex < BricksAtCurrentDepth.Num(); BrickIndex++)
	{
		const FImportedVolumetricLightmapBrick& Brick = *BricksAtCurrentDepth[BrickIndex];
		const FIntVector BrickLayoutPosition = ComputeBrickLayoutPosition(BrickStartAllocation + BrickIndex, BrickLayoutDimensions) * PaddedBrickSize;
		const int32 DetailCellsPerCurrentLevelBrick = 1 << ((VolumetricLightmapSettings.MaxRefinementLevels - Brick.TreeDepth) * BrickSizeLog2);
		const int32 NumBottomLevelBricks = DetailCellsPerCurrentLevelBrick / BrickSize;
		const FVector IndirectionTexturePosition = FVector(Brick.IndirectionTexturePosition);

		int32 X, Y, Z = 0;

		// Iterate over unique data on the edge of the brick which needs to match padding on lower resolution bricks
		for (X = 0, Z = 0; Z < BrickSize; Z++)
		{
			for (Y = 0; Y < BrickSize; Y++)
			{
				FVector IndirectionDataSourceCoordinate = IndirectionTexturePosition + FVector(X, Y, Z) * InvBrickSize * NumBottomLevelBricks;

				for (int32 StitchDirection = 1; StitchDirection < 8; StitchDirection++)
				{
					FVector StitchSourceCoordinate = IndirectionDataSourceCoordinate;

					if ((StitchDirection & 1) && X == 0)
					{
						StitchSourceCoordinate.X -= GPointFilteringThreshold * 2;
					}

					if ((StitchDirection & 2) && Y == 0)
					{
						StitchSourceCoordinate.Y -= GPointFilteringThreshold * 2;
					}

					if ((StitchDirection & 4) && Z == 0)
					{
						StitchSourceCoordinate.Z -= GPointFilteringThreshold * 2;
					}

					if (StitchSourceCoordinate != IndirectionDataSourceCoordinate)
					{
						bool bStitched = CopyFromBrickmapTexel(
							StitchSourceCoordinate,
							FIntVector(X, Y, Z),
							// Restrict copies to only read from bricks that are lower effective resolution (higher NumBottomLevelBricks)
							NumBottomLevelBricks,
							BrickSize,
							BrickLayoutPosition,
							CurrentLevelData,
							CurrentLevelData.BrickData);

						if (bStitched)
						{
							break;
						}
					}
				}
			}
		}

		for (Z = 0, Y = 0; Y < BrickSize; Y++)
		{
			for (X = 1; X < BrickSize; X++)
			{
				FVector IndirectionDataSourceCoordinate = IndirectionTexturePosition + FVector(X, Y, Z) * InvBrickSize * NumBottomLevelBricks;
									
				for (int32 StitchDirection = 1; StitchDirection < 8; StitchDirection++)
				{
					FVector StitchSourceCoordinate = IndirectionDataSourceCoordinate;

					if ((StitchDirection & 1) && X == 0)
					{
						StitchSourceCoordinate.X -= GPointFilteringThreshold * 2;
					}

					if ((StitchDirection & 2) && Y == 0)
					{
						StitchSourceCoordinate.Y -= GPointFilteringThreshold * 2;
					}

					if ((StitchDirection & 4) && Z == 0)
					{
						StitchSourceCoordinate.Z -= GPointFilteringThreshold * 2;
					}

					if (StitchSourceCoordinate != IndirectionDataSourceCoordinate)
					{
						bool bStitched = CopyFromBrickmapTexel(
							StitchSourceCoordinate,
							FIntVector(X, Y, Z),
							// Restrict copies to only read from bricks that are lower effective resolution (higher NumBottomLevelBricks)
							NumBottomLevelBricks,
							BrickSize,
							BrickLayoutPosition,
							CurrentLevelData,
							CurrentLevelData.BrickData);

						if (bStitched)
						{
							break;
						}
					}
				}
			}
		}

		for (Y = 0, Z = 1; Z < BrickSize; Z++)
		{
			for (X = 1; X < BrickSize; X++)
			{
				FVector IndirectionDataSourceCoordinate = IndirectionTexturePosition + FVector(X, Y, Z) * InvBrickSize * NumBottomLevelBricks;
								
				for (int32 StitchDirection = 1; StitchDirection < 8; StitchDirection++)
				{
					FVector StitchSourceCoordinate = IndirectionDataSourceCoordinate;

					if ((StitchDirection & 1) && X == 0)
					{
						StitchSourceCoordinate.X -= GPointFilteringThreshold * 2;
					}

					if ((StitchDirection & 2) && Y == 0)
					{
						StitchSourceCoordinate.Y -= GPointFilteringThreshold * 2;
					}

					if ((StitchDirection & 4) && Z == 0)
					{
						StitchSourceCoordinate.Z -= GPointFilteringThreshold * 2;
					}

					if (StitchSourceCoordinate != IndirectionDataSourceCoordinate)
					{
						bool bStitched = CopyFromBrickmapTexel(
							StitchSourceCoordinate,
							FIntVector(X, Y, Z),
							// Restrict copies to only read from bricks that are lower effective resolution (higher NumBottomLevelBricks)
							NumBottomLevelBricks,
							BrickSize,
							BrickLayoutPosition,
							CurrentLevelData,
							CurrentLevelData.BrickData);

						if (bStitched)
						{
							break;
						}
					}
				}
			}
		}
	}
}

void CopyPaddingFromUniqueData(
	const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth,
	int32 BrickStartAllocation,
	int32 CurrentDepth,
	FIntVector BrickLayoutDimensions,
	const Lightmass::FVolumetricLightmapSettings& VolumetricLightmapSettings,
	const FPrecomputedVolumetricLightmapData& CurrentLevelData,
	FVolumetricLightmapBrickData& BrickData)
{
	int32 BrickSize = VolumetricLightmapSettings.BrickSize;
	int32 PaddedBrickSize = BrickSize + 1;
	const int32 BrickSizeLog2 = FMath::FloorLog2(BrickSize);
	const float InvBrickSize = 1.0f / BrickSize;

	for (int32 BrickIndex = 0; BrickIndex < BricksAtCurrentDepth.Num(); BrickIndex++)
	{
		const FImportedVolumetricLightmapBrick& Brick = *BricksAtCurrentDepth[BrickIndex];
		const FIntVector BrickLayoutPosition = ComputeBrickLayoutPosition(BrickStartAllocation + BrickIndex, BrickLayoutDimensions) * PaddedBrickSize;
		const int32 DetailCellsPerCurrentLevelBrick = 1 << ((VolumetricLightmapSettings.MaxRefinementLevels - Brick.TreeDepth) * BrickSizeLog2);
		const int32 NumBottomLevelBricks = DetailCellsPerCurrentLevelBrick / BrickSize;
		const FVector IndirectionTexturePosition = FVector(Brick.IndirectionTexturePosition);

		int32 X, Y, Z = 0;

		// Iterate over padding voxels
		for (X = PaddedBrickSize - 1, Z = 0; Z < PaddedBrickSize; Z++)
		{
			for (Y = 0; Y < PaddedBrickSize; Y++)
			{
				const FVector IndirectionDataSourceCoordinate = IndirectionTexturePosition + FVector(X, Y, Z) * InvBrickSize * NumBottomLevelBricks;

				// Overwrite padding with unique data from this same coordinate in the indirection texture
				CopyFromBrickmapTexel(
					IndirectionDataSourceCoordinate,
					FIntVector(X, Y, Z),
					0,
					BrickSize,
					BrickLayoutPosition,
					CurrentLevelData,
					BrickData);
			}
		}

		for (Z = PaddedBrickSize - 1, Y = 0; Y < PaddedBrickSize; Y++)
		{
			for (X = 0; X < PaddedBrickSize; X++)
			{
				const FVector IndirectionDataSourceCoordinate = IndirectionTexturePosition + FVector(X, Y, Z) * InvBrickSize * NumBottomLevelBricks;

				CopyFromBrickmapTexel(
					IndirectionDataSourceCoordinate,
					FIntVector(X, Y, Z),
					0,
					BrickSize,
					BrickLayoutPosition,
					CurrentLevelData,
					BrickData);
			}
		}

		for (Y = PaddedBrickSize - 1, Z = 0; Z < PaddedBrickSize; Z++)
		{
			for (X = 0; X < PaddedBrickSize; X++)
			{
				const FVector IndirectionDataSourceCoordinate = IndirectionTexturePosition + FVector(X, Y, Z) * InvBrickSize * NumBottomLevelBricks;

				CopyFromBrickmapTexel(
					IndirectionDataSourceCoordinate,
					FIntVector(X, Y, Z),
					0,
					BrickSize,
					BrickLayoutPosition,
					CurrentLevelData,
					BrickData);
			}
		}
	}
}

FVector GetLookupPositionAwayFromBorder(int32 PaddedBrickSize, FIntVector LocalCellCoordinate)
{
	FVector LookupCoordinate(LocalCellCoordinate);

	if (LocalCellCoordinate.X == PaddedBrickSize - 1)
	{
		LookupCoordinate.X -= 1;
	}

	if (LocalCellCoordinate.Y == PaddedBrickSize - 1)
	{
		LookupCoordinate.Y -= 1;
	}

	if (LocalCellCoordinate.Z == PaddedBrickSize - 1)
	{
		LookupCoordinate.Z -= 1;
	}

	return LookupCoordinate;
}

void CopyVolumeBorderFromInterior(
	const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth,
	int32 BrickStartAllocation,
	int32 CurrentDepth,
	FIntVector BrickLayoutDimensions,
	const Lightmass::FVolumetricLightmapSettings& VolumetricLightmapSettings,
	FPrecomputedVolumetricLightmapData& CurrentLevelData,
	FVolumetricLightmapBrickData& BrickData)
{
	int32 BrickSize = VolumetricLightmapSettings.BrickSize;
	int32 PaddedBrickSize = BrickSize + 1;
	const int32 BrickSizeLog2 = FMath::FloorLog2(BrickSize);
	const float InvBrickSize = 1.0f / BrickSize;

	for (int32 BrickIndex = 0; BrickIndex < BricksAtCurrentDepth.Num(); BrickIndex++)
	{
		const FImportedVolumetricLightmapBrick& Brick = *BricksAtCurrentDepth[BrickIndex];
		const FIntVector BrickLayoutPosition = ComputeBrickLayoutPosition(BrickStartAllocation + BrickIndex, BrickLayoutDimensions) * PaddedBrickSize;
		const int32 DetailCellsPerCurrentLevelBrick = 1 << ((VolumetricLightmapSettings.MaxRefinementLevels - Brick.TreeDepth) * BrickSizeLog2);
		const int32 NumBottomLevelBricks = DetailCellsPerCurrentLevelBrick / BrickSize;
		const FVector IndirectionTexturePosition = FVector(Brick.IndirectionTexturePosition);

		// Operate on bricks on the edge of the volume covered by the indirection texture
		if (Brick.IndirectionTexturePosition.X + NumBottomLevelBricks == CurrentLevelData.IndirectionTextureDimensions.X)
		{
			int32 X, Y, Z = 0;

			// Iterate over padding voxels
			for (X = PaddedBrickSize - 1, Z = 0; Z < PaddedBrickSize; Z++)
			{
				for (Y = 0; Y < PaddedBrickSize; Y++)
				{
					const FVector LookupPosition = GetLookupPositionAwayFromBorder(PaddedBrickSize, FIntVector(X, Y, Z));
					const FVector IndirectionDataSourceCoordinate = IndirectionTexturePosition + LookupPosition * InvBrickSize * NumBottomLevelBricks;

					// Overwrite padding on the edge of the volume with neighboring data inside the volume
					CopyFromBrickmapTexel(
						IndirectionDataSourceCoordinate,
						FIntVector(X, Y, Z),
						0,
						BrickSize,
						BrickLayoutPosition,
						CurrentLevelData,
						BrickData);
				}
			}
		}

		if (Brick.IndirectionTexturePosition.Y + NumBottomLevelBricks == CurrentLevelData.IndirectionTextureDimensions.Y)
		{
			int32 X, Y, Z = 0;

			// Iterate over padding voxels
			for (Y = PaddedBrickSize - 1, Z = 0; Z < PaddedBrickSize; Z++)
			{
				for (X = 0; X < PaddedBrickSize; X++)
				{
					const FVector LookupPosition = GetLookupPositionAwayFromBorder(PaddedBrickSize, FIntVector(X, Y, Z));
					const FVector IndirectionDataSourceCoordinate = IndirectionTexturePosition + LookupPosition * InvBrickSize * NumBottomLevelBricks;

					CopyFromBrickmapTexel(
						IndirectionDataSourceCoordinate,
						FIntVector(X, Y, Z),
						0,
						BrickSize,
						BrickLayoutPosition,
						CurrentLevelData,
						BrickData);
				}
			}
		}

		if (Brick.IndirectionTexturePosition.Z + NumBottomLevelBricks == CurrentLevelData.IndirectionTextureDimensions.Z)
		{
			int32 X, Y, Z = 0;

			// Iterate over padding voxels
			for (Z = PaddedBrickSize - 1, Y = 0; Y < PaddedBrickSize; Y++)
			{
				for (X = 0; X < PaddedBrickSize; X++)
				{
					const FVector LookupPosition = GetLookupPositionAwayFromBorder(PaddedBrickSize, FIntVector(X, Y, Z));
					const FVector IndirectionDataSourceCoordinate = IndirectionTexturePosition + LookupPosition * InvBrickSize * NumBottomLevelBricks;

					CopyFromBrickmapTexel(
						IndirectionDataSourceCoordinate,
						FIntVector(X, Y, Z),
						0,
						BrickSize,
						BrickLayoutPosition,
						CurrentLevelData,
						BrickData);
				}
			}
		}
	}
}

int32 TrimBricksByInterpolationError(
	TArray<TArray<const FImportedVolumetricLightmapBrick*>>& BricksByDepth,
	const Lightmass::FVolumetricLightmapSettings& VolumetricLightmapSettings)
{
	int32 NumBricksRemoved = 0;

	if (VolumetricLightmapSettings.MaxRefinementLevels > 1)
	{
		TArray<const FImportedVolumetricLightmapBrick*>& HighestDensityBricks = BricksByDepth[VolumetricLightmapSettings.MaxRefinementLevels - 1];
		const int32 ParentLevel = VolumetricLightmapSettings.MaxRefinementLevels - 2;
		TArray<const FImportedVolumetricLightmapBrick*>& ParentLevelBricks = BricksByDepth[ParentLevel];

		const int32 BrickSize = VolumetricLightmapSettings.BrickSize;
		const float InvTotalBrickSize = 1.0f / (BrickSize * BrickSize * BrickSize);
		const int32 BrickSizeLog2 = FMath::FloorLog2(BrickSize);
		const int32 DetailCellsPerParentLevelBrick = 1 << ((VolumetricLightmapSettings.MaxRefinementLevels - ParentLevel) * BrickSizeLog2);
		const int32 NumParentBottomLevelBricks = DetailCellsPerParentLevelBrick / BrickSize;

		for (int32 BrickIndex = 0; BrickIndex < HighestDensityBricks.Num(); BrickIndex++)
		{
			const FImportedVolumetricLightmapBrick& Brick = *HighestDensityBricks[BrickIndex];
			const FImportedVolumetricLightmapBrick* ParentBrick = NULL;

			for (int32 ParentBrickIndex = 0; ParentBrickIndex < ParentLevelBricks.Num(); ParentBrickIndex++)
			{
				const FImportedVolumetricLightmapBrick& ParentLevelBrick = *ParentLevelBricks[ParentBrickIndex];

				if (Brick.IndirectionTexturePosition.X >= ParentLevelBrick.IndirectionTexturePosition.X
					&& Brick.IndirectionTexturePosition.Y >= ParentLevelBrick.IndirectionTexturePosition.Y
					&& Brick.IndirectionTexturePosition.Z >= ParentLevelBrick.IndirectionTexturePosition.Z
					&& Brick.IndirectionTexturePosition.X < ParentLevelBrick.IndirectionTexturePosition.X + NumParentBottomLevelBricks
					&& Brick.IndirectionTexturePosition.Y < ParentLevelBrick.IndirectionTexturePosition.Y + NumParentBottomLevelBricks
					&& Brick.IndirectionTexturePosition.Z < ParentLevelBrick.IndirectionTexturePosition.Z + NumParentBottomLevelBricks)
				{
					ParentBrick = &ParentLevelBrick;
					break;
				}
			}

			check(ParentBrick);

			FVector ErrorSquared(0, 0, 0);
			const FVector ChildOffset = FVector(Brick.IndirectionTexturePosition - ParentBrick->IndirectionTexturePosition);

			for (int32 Z = 0; Z < BrickSize; Z++)
			{
				for (int32 Y = 0; Y < BrickSize; Y++)
				{
					for (int32 X = 0; X < BrickSize; X++)
					{
						const FIntVector VoxelCoordinate(X, Y, Z);
						const int32 LinearVoxelIndex = ComputeLinearVoxelIndex(VoxelCoordinate, FIntVector(BrickSize, BrickSize, BrickSize));
						const FVector AmbientVector = FVector(Brick.AmbientVector[LinearVoxelIndex].ToLinearColor());

						const FVector ParentCoordinate = FVector(VoxelCoordinate) / (float)BrickSize + ChildOffset;
						const FVector ParentAmbientVector = FVector(FilteredVolumeLookup(ParentCoordinate, FIntVector(BrickSize, BrickSize, BrickSize), ParentBrick->AmbientVector.GetData()));
						ErrorSquared += (AmbientVector - ParentAmbientVector) * (AmbientVector - ParentAmbientVector);
					}
				}
			}

			const double RMSE = FMath::Sqrt((ErrorSquared * InvTotalBrickSize).GetMax());
			const bool bCullBrick = RMSE < VolumetricLightmapSettings.MinBrickError;

			if (bCullBrick)
			{
				HighestDensityBricks.RemoveAt(BrickIndex);
				BrickIndex--;
				NumBricksRemoved++;
			}
		}
	}

	return NumBricksRemoved;
}

int32 TrimBricksForMemoryLimit(
	TArray<TArray<const FImportedVolumetricLightmapBrick*>>& BricksByDepth,
	const Lightmass::FVolumetricLightmapSettings& VolumetricLightmapSettings,
	int32 VoxelSizeBytes,
	const float MaximumBrickMemoryMb)
{
	int32 NumBricksBeforeTrimming = 0;

	for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
	{
		const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];
		NumBricksBeforeTrimming += BricksAtCurrentDepth.Num();
	}

	const int32 PaddedBrickSize = VolumetricLightmapSettings.BrickSize + 1;
	TArray<const FImportedVolumetricLightmapBrick*>& HighestDensityBricks = BricksByDepth[VolumetricLightmapSettings.MaxRefinementLevels - 1];

	const uint64 BrickSizeBytes = VoxelSizeBytes * PaddedBrickSize * PaddedBrickSize * PaddedBrickSize;
	const uint64 MaxBrickBytes = static_cast<uint64>(MaximumBrickMemoryMb * 1024 * 1024);
	check(FMath::DivideAndRoundUp(MaxBrickBytes, BrickSizeBytes) <= 0x7FFFFFFFull);
	const int32 NumBricksBudgeted = (int32)FMath::DivideAndRoundUp(MaxBrickBytes, BrickSizeBytes);
	const int32 NumBricksToRemove = FMath::Clamp<int32>(NumBricksBeforeTrimming - NumBricksBudgeted, 0, HighestDensityBricks.Num());

	if (NumBricksToRemove > 0)
	{
		struct FCompareBricksByVisualImpact
		{
			FORCEINLINE bool operator()(const FImportedVolumetricLightmapBrick& A, const FImportedVolumetricLightmapBrick& B) const
			{
				// Sort smallest to largest
				return A.AverageClosestGeometryDistance < B.AverageClosestGeometryDistance;
			}
		};

		HighestDensityBricks.Sort(FCompareBricksByVisualImpact());
		HighestDensityBricks.RemoveAt(HighestDensityBricks.Num() - NumBricksToRemove, NumBricksToRemove);
	}

	return NumBricksToRemove;
}

void BuildIndirectionTexture(
	const TArray<TArray<const FImportedVolumetricLightmapBrick*>>& BricksByDepth,
	const Lightmass::FVolumetricLightmapSettings& VolumetricLightmapSettings,
	int32 MaxBricksInLayoutOneDim,
	FIntVector BrickLayoutDimensions,
	int32 IndirectionTextureDataStride,
	FPrecomputedVolumetricLightmapData& CurrentLevelData,
	bool bOnlyBuildForPersistentLevel)
{
	const int32 BrickSizeLog2 = FMath::FloorLog2(VolumetricLightmapSettings.BrickSize);

	int32 BrickAllocation = 0;

	for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
	{
		const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];

		for (int32 BrickIndex = 0; BrickIndex < BricksAtCurrentDepth.Num(); BrickIndex++)
		{
			const FImportedVolumetricLightmapBrick& Brick = *BricksAtCurrentDepth[BrickIndex];

			if (CurrentDepth == VolumetricLightmapSettings.MaxRefinementLevels - 1)
			{
				const FGuid PersistentLevelGuid = FGuid(0, 0, 0, 0);

				// Skip non-intersecting, bottom detailed bricks for persistent level
				if (bOnlyBuildForPersistentLevel && Brick.IntersectingLevelGuid != PersistentLevelGuid)
				{
					continue;
				}
			}

			const FIntVector BrickLayoutPosition = ComputeBrickLayoutPosition(BrickAllocation, BrickLayoutDimensions);
			check(BrickLayoutPosition.X < MaxBricksInLayoutOneDim && BrickLayoutPosition.Y < MaxBricksInLayoutOneDim && BrickLayoutPosition.Z < MaxBricksInLayoutOneDim);
			checkSlow(IndirectionTextureDataStride == sizeof(uint8) * 4);

			const int32 DetailCellsPerCurrentLevelBrick = 1 << ((VolumetricLightmapSettings.MaxRefinementLevels - Brick.TreeDepth) * BrickSizeLog2);
			const int32 NumBottomLevelBricks = DetailCellsPerCurrentLevelBrick / VolumetricLightmapSettings.BrickSize;
			check(NumBottomLevelBricks < MaxBricksInLayoutOneDim);

			for (int32 Z = 0; Z < NumBottomLevelBricks; Z++)
			{
				for (int32 Y = 0; Y < NumBottomLevelBricks; Y++)
				{
					for (int32 X = 0; X < NumBottomLevelBricks; X++)
					{
						const FIntVector IndirectionDestDataCoordinate = Brick.IndirectionTexturePosition + FIntVector(X, Y, Z);
						const int32 IndirectionDestDataIndex = ((IndirectionDestDataCoordinate.Z * CurrentLevelData.IndirectionTextureDimensions.Y) + IndirectionDestDataCoordinate.Y) * CurrentLevelData.IndirectionTextureDimensions.X + IndirectionDestDataCoordinate.X;
						uint8* IndirectionVoxelPtr = (uint8*)&CurrentLevelData.IndirectionTexture.Data[IndirectionDestDataIndex * IndirectionTextureDataStride];
						*(IndirectionVoxelPtr + 0) = static_cast<uint8>(BrickLayoutPosition.X);
						*(IndirectionVoxelPtr + 1) = static_cast<uint8>(BrickLayoutPosition.Y);
						*(IndirectionVoxelPtr + 2) = static_cast<uint8>(BrickLayoutPosition.Z);
						*(IndirectionVoxelPtr + 3) = static_cast<uint8>(NumBottomLevelBricks);
					}
				}
			}

			BrickAllocation++;
		}
	}
}

inline void ConvertBGRA8ToRGBA8ForLayer(FVolumetricLightmapDataLayer& Layer)
{
	if (Layer.Format == PF_B8G8R8A8)
	{
		for (int32 PixelIndex = 0; PixelIndex < Layer.Data.Num() / GPixelFormats[PF_B8G8R8A8].BlockBytes; PixelIndex++)
		{
			FColor Color;

			Color.B = Layer.Data[PixelIndex * 4 + 0];
			Color.G = Layer.Data[PixelIndex * 4 + 1];
			Color.R = Layer.Data[PixelIndex * 4 + 2];
			Color.A = Layer.Data[PixelIndex * 4 + 3];

			Layer.Data[PixelIndex * 4 + 0] = Color.R;
			Layer.Data[PixelIndex * 4 + 1] = Color.G;
			Layer.Data[PixelIndex * 4 + 2] = Color.B;
			Layer.Data[PixelIndex * 4 + 3] = Color.A;
		}

		Layer.Format = PF_R8G8B8A8;
	}
}

// For debugging
bool bStitchDetailBricksWithLowDensityNeighbors = true;
bool bCopyPaddingFromUniqueData = true;
bool bCopyVolumeBorderFromInterior = true;

void FLightmassProcessor::SetVolumetricLightMapImportMode(bool bUseVLMCellGrid)
{
	bSplitToVLMCellGrid = bUseVLMCellGrid;
}

void FLightmassProcessor::ImportVolumetricLightmap()
{
	const double StartTime = FPlatformTime::Seconds();

	Lightmass::FVolumetricLightmapSettings VolumetricLightmapSettings;
	GetLightmassExporter()->SetVolumetricLightmapSettings(VolumetricLightmapSettings);

	const int32 BrickSize = VolumetricLightmapSettings.BrickSize;
	const int32 PaddedBrickSize = VolumetricLightmapSettings.BrickSize + 1;
	const int32 MaxBricksInLayoutOneDim = 1 << 8;
	const int32 MaxBrickTextureLayoutSize = PaddedBrickSize * MaxBricksInLayoutOneDim;
	const FGuid PersistentLevelGuid = FGuid(0, 0, 0, 0);

	TArray<FImportedVolumetricLightmapTaskData> TaskDataArray;
	TaskDataArray.Empty(Exporter->VolumetricLightmapTaskGuids.Num());

	bool bGenerateSkyShadowing = false;

	int32 LocalNumCompletedVolumetricLightmapTasks = FPlatformAtomics::AtomicRead(&NumCompletedVolumetricLightmapTasks);
	if (Exporter->VolumetricLightmapTaskGuids.Num() != LocalNumCompletedVolumetricLightmapTasks)
	{
		FMessageLog("LightingResults").Error(
			FText::Format(
				LOCTEXT("LightmassError_VolumetricLightmapImportFailed_NotAllCompleted", "Import Volumetric Lightmap failed: Expected {0} tasks, only {1} were reported as completed from Swarm"), 
				FText::AsNumber(Exporter->VolumetricLightmapTaskGuids.Num()), 
				FText::AsNumber(LocalNumCompletedVolumetricLightmapTasks)
			)
		);

		return;
	}

	ImportIrradianceTasks(bGenerateSkyShadowing, TaskDataArray);

	if (TaskDataArray.Num() != Exporter->VolumetricLightmapTaskGuids.Num())
	{
		FMessageLog("LightingResults").Error(
			FText::Format(
				LOCTEXT("LightmassError_VolumetricLightmapImportFailed_FewerThanExpectedImported", "Import Volumetric Lightmap failed: Expected {0} tasks, only found {1}"),
				FText::AsNumber(Exporter->VolumetricLightmapTaskGuids.Num()),
				FText::AsNumber(TaskDataArray.Num())
			)
		);

		return;
	}

	TArray<TArray<const FImportedVolumetricLightmapBrick*>> BricksByDepth;
	BricksByDepth.Empty(VolumetricLightmapSettings.MaxRefinementLevels);
	BricksByDepth.AddDefaulted(VolumetricLightmapSettings.MaxRefinementLevels);

	for (int32 TaskDataIndex = 0; TaskDataIndex < TaskDataArray.Num(); TaskDataIndex++)
	{
		const FImportedVolumetricLightmapTaskData& TaskData = TaskDataArray[TaskDataIndex];

		for (int32 BrickIndex = 0; BrickIndex < TaskData.Bricks.Num(); BrickIndex++)
		{
			const FImportedVolumetricLightmapBrick& Brick = TaskData.Bricks[BrickIndex];
			BricksByDepth[Brick.TreeDepth].Add(&Brick);
		}
	}

	UMapBuildDataRegistry* Registry = System.LightingContext.GetOrCreateGlobalRegistry();
	FPrecomputedVolumetricLightmapData CurrentLevelData;

	{
		CurrentLevelData.InitializeOnImport(FBox(VolumetricLightmapSettings.VolumeMin, VolumetricLightmapSettings.VolumeMin + VolumetricLightmapSettings.VolumeSize), BrickSize);

		// Temporarily assign format as PF_B8G8R8A8 since that matches FColor and makes our operations easier
		// Will be converted to PF_R8G8B8A8 by ConvertBGRA8ToRGBA8ForLayer() later
		CurrentLevelData.BrickData.AmbientVector.Format = PF_FloatR11G11B10;
		CurrentLevelData.BrickData.SkyBentNormal.Format = PF_B8G8R8A8;
		CurrentLevelData.BrickData.DirectionalLightShadowing.Format = PF_G8;

		for (int32 i = 0; i < UE_ARRAY_COUNT(CurrentLevelData.BrickData.SHCoefficients); i++)
		{
			CurrentLevelData.BrickData.SHCoefficients[i].Format = PF_B8G8R8A8;
		}
	}

	const int32 NumBottomLevelBricksTrimmedByInterpolationError = TrimBricksByInterpolationError(BricksByDepth, VolumetricLightmapSettings);

	const float MaximumBrickMemoryMb = System.GetWorld()->GetWorldSettings()->LightmassSettings.VolumetricLightmapMaximumBrickMemoryMb;

	// avoid trimming for memory if we're going to output the bricks to streaming grid
	// @todo_ow: Have a trim limit for base data + one limit per cell for the highest level bricks
	const int32 NumBottomLevelBricksTrimmedForMemoryLimit = bSplitToVLMCellGrid ? 0 : TrimBricksForMemoryLimit(BricksByDepth, VolumetricLightmapSettings, CurrentLevelData.BrickData.GetMinimumVoxelSize(), MaximumBrickMemoryMb);

	int32 BrickTextureLinearAllocator = 0;

	for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
	{
		const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];
		BrickTextureLinearAllocator += BricksAtCurrentDepth.Num();
	}

	FIntVector BrickLayoutDimensions;
	BrickLayoutDimensions.X = FMath::Min(BrickTextureLinearAllocator, MaxBricksInLayoutOneDim);
	BrickTextureLinearAllocator = FMath::DivideAndRoundUp(BrickTextureLinearAllocator, BrickLayoutDimensions.X);
	BrickLayoutDimensions.Y = FMath::Min(BrickTextureLinearAllocator, MaxBricksInLayoutOneDim);
	BrickTextureLinearAllocator = FMath::DivideAndRoundUp(BrickTextureLinearAllocator, BrickLayoutDimensions.Y);
	BrickLayoutDimensions.Z = FMath::Min(BrickTextureLinearAllocator, MaxBricksInLayoutOneDim);

	const int32 BrickSizeLog2 = FMath::FloorLog2(BrickSize);
	const int32 DetailCellsPerTopLevelBrick = 1 << (VolumetricLightmapSettings.MaxRefinementLevels * BrickSizeLog2);
	const int32 IndirectionCellsPerTopLevelCell = DetailCellsPerTopLevelBrick / BrickSize;

	int32 IndirectionTextureDataStride;
	{
		CurrentLevelData.IndirectionTextureDimensions = VolumetricLightmapSettings.TopLevelGridSize * IndirectionCellsPerTopLevelCell;
		CurrentLevelData.IndirectionTexture.Format = PF_R8G8B8A8_UINT;
		IndirectionTextureDataStride = GPixelFormats[CurrentLevelData.IndirectionTexture.Format].BlockBytes;

		const int32 TotalIndirectionTextureSize = CurrentLevelData.IndirectionTextureDimensions.X * CurrentLevelData.IndirectionTextureDimensions.Y * CurrentLevelData.IndirectionTextureDimensions.Z;
		CurrentLevelData.IndirectionTexture.Resize(TotalIndirectionTextureSize * IndirectionTextureDataStride);
	}

	BuildIndirectionTexture(BricksByDepth, VolumetricLightmapSettings, MaxBricksInLayoutOneDim, BrickLayoutDimensions, IndirectionTextureDataStride, CurrentLevelData, false);

	TArray<Lightmass::FIrradianceVoxelImportProcessingData> VoxelImportProcessingData;

	{
		CurrentLevelData.BrickDataDimensions = BrickLayoutDimensions * PaddedBrickSize;
		const int32 TotalBrickDataSize = CurrentLevelData.BrickDataDimensions.X * CurrentLevelData.BrickDataDimensions.Y * CurrentLevelData.BrickDataDimensions.Z;

		CurrentLevelData.BrickData.AmbientVector.Resize(TotalBrickDataSize * GPixelFormats[CurrentLevelData.BrickData.AmbientVector.Format].BlockBytes);

		if (bGenerateSkyShadowing)
		{
			CurrentLevelData.BrickData.SkyBentNormal.Resize(TotalBrickDataSize * GPixelFormats[CurrentLevelData.BrickData.SkyBentNormal.Format].BlockBytes);
		}

		CurrentLevelData.BrickData.DirectionalLightShadowing.Resize(TotalBrickDataSize * GPixelFormats[CurrentLevelData.BrickData.DirectionalLightShadowing.Format].BlockBytes);

		for (int32 i = 0; i < UE_ARRAY_COUNT(CurrentLevelData.BrickData.SHCoefficients); i++)
		{
			const int32 Stride = GPixelFormats[CurrentLevelData.BrickData.SHCoefficients[i].Format].BlockBytes;
			CurrentLevelData.BrickData.SHCoefficients[i].Resize(TotalBrickDataSize * Stride);
		}

		VoxelImportProcessingData.Empty(TotalBrickDataSize);
		VoxelImportProcessingData.AddZeroed(TotalBrickDataSize);
	}

	int32 BrickStartAllocation = 0;

	for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
	{
		const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];

		for (int32 BrickIndex = 0; BrickIndex < BricksAtCurrentDepth.Num(); BrickIndex++)
		{
			const FImportedVolumetricLightmapBrick& Brick = *BricksAtCurrentDepth[BrickIndex];
			const FIntVector BrickLayoutPosition = ComputeBrickLayoutPosition(BrickStartAllocation + BrickIndex, BrickLayoutDimensions) * PaddedBrickSize;

			CopyBrickToAtlasVolumeTexture(
				GPixelFormats[CurrentLevelData.BrickData.AmbientVector.Format].BlockBytes,
				CurrentLevelData.BrickDataDimensions,
				BrickLayoutPosition,
				FIntVector(BrickSize),
				(const uint8*)Brick.AmbientVector.GetData(),
				CurrentLevelData.BrickData.AmbientVector.Data.GetData());

			for (int32 i = 0; i < UE_ARRAY_COUNT(Brick.SHCoefficients); i++)
			{
				CopyBrickToAtlasVolumeTexture(
					GPixelFormats[CurrentLevelData.BrickData.SHCoefficients[i].Format].BlockBytes,
					CurrentLevelData.BrickDataDimensions,
					BrickLayoutPosition,
					FIntVector(BrickSize),
					(const uint8*)Brick.SHCoefficients[i].GetData(),
					CurrentLevelData.BrickData.SHCoefficients[i].Data.GetData());
			}

			if (bGenerateSkyShadowing)
			{
				CopyBrickToAtlasVolumeTexture(
					GPixelFormats[CurrentLevelData.BrickData.SkyBentNormal.Format].BlockBytes,
					CurrentLevelData.BrickDataDimensions,
					BrickLayoutPosition,
					FIntVector(BrickSize),
					(const uint8*)Brick.SkyBentNormal.GetData(),
					CurrentLevelData.BrickData.SkyBentNormal.Data.GetData());
			}

			CopyBrickToAtlasVolumeTexture(
				GPixelFormats[CurrentLevelData.BrickData.DirectionalLightShadowing.Format].BlockBytes,
				CurrentLevelData.BrickDataDimensions,
				BrickLayoutPosition,
				FIntVector(BrickSize),
				(const uint8*)Brick.DirectionalLightShadowing.GetData(),
				CurrentLevelData.BrickData.DirectionalLightShadowing.Data.GetData());

			CopyBrickToAtlasVolumeTexture(
				VoxelImportProcessingData.GetTypeSize(),
				CurrentLevelData.BrickDataDimensions,
				BrickLayoutPosition,
				FIntVector(BrickSize),
				(const uint8*)Brick.TaskVoxelImportProcessingData.GetData(),
				(uint8*)VoxelImportProcessingData.GetData());
		}

		BrickStartAllocation += BricksAtCurrentDepth.Num();
	}

	const float InvBrickSize = 1.0f / BrickSize;
	const FVector DetailCellSize = FVector(VolumetricLightmapSettings.VolumeSize) / FVector(VolumetricLightmapSettings.TopLevelGridSize * DetailCellsPerTopLevelBrick);

	for (int32 DilatePassIndex = 0; DilatePassIndex < NumDilateOverEmbeddedVoxelsPasses; DilatePassIndex++)
	{
		BrickStartAllocation = 0;

		// Compute the allocation start for the highest density level bricks
		for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels - 1; CurrentDepth++)
		{
			BrickStartAllocation += BricksByDepth[CurrentDepth].Num();
		}

		TArray<const FImportedVolumetricLightmapBrick*>& HighestDensityBricks = BricksByDepth[VolumetricLightmapSettings.MaxRefinementLevels - 1];

		// Need to double buffer bInsideGeometry as it is both read and written
		TArray<Lightmass::FIrradianceVoxelImportProcessingData> NewVoxelImportProcessingData = VoxelImportProcessingData;

		// Reads from unique data of any density bricks, writes to unique data
		// This is doing a filter in-place, which is only reliable because source and dest voxels are mutually exclusive
		FilterWithNeighbors(
			HighestDensityBricks,
			BrickStartAllocation,
			VolumetricLightmapSettings.MaxRefinementLevels - 1,
			BrickLayoutDimensions,
			VolumetricLightmapSettings,
			CurrentLevelData,
			VoxelImportProcessingData,
			NewVoxelImportProcessingData);

		VoxelImportProcessingData = MoveTemp(NewVoxelImportProcessingData);
	}

	BrickStartAllocation = 0;

	for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
	{
		const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];

		if (bStitchDetailBricksWithLowDensityNeighbors && CurrentDepth > 0)
		{
			// Reads from both unique and padding data of lower density bricks, writes to unique data
			StitchDetailBricksWithLowDensityNeighbors(
				BricksAtCurrentDepth,
				BrickStartAllocation,
				CurrentDepth,
				BrickLayoutDimensions,
				VolumetricLightmapSettings,
				CurrentLevelData);
		}

		if (bCopyPaddingFromUniqueData)
		{
			// Compute padding for all the bricks
			// Reads from unique data, writes to padding data of bricks
			// Padding must be computed after all operations that might modify the unique data
			CopyPaddingFromUniqueData(
				BricksAtCurrentDepth,
				BrickStartAllocation,
				CurrentDepth,
				BrickLayoutDimensions,
				VolumetricLightmapSettings,
				CurrentLevelData,
				CurrentLevelData.BrickData);
		}

		if (bCopyVolumeBorderFromInterior)
		{
			// The volume border padding had no unique data to copy from, replicate the neighboring interior value
			CopyVolumeBorderFromInterior(
				BricksAtCurrentDepth,
				BrickStartAllocation,
				CurrentDepth,
				BrickLayoutDimensions,
				VolumetricLightmapSettings,
				CurrentLevelData,
				CurrentLevelData.BrickData);
		}

		BrickStartAllocation += BricksAtCurrentDepth.Num();
	}

	TMap<FGuid, int32> SubLevelTotalBricks;
	TMap<FGuid, int32> SubLevelBrickAllocator;
	TMap<FGuid, FIntVector> SubLevelBrickLayoutDimensions;

	{
		for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
		{
			const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];

			for (int32 BrickIndex = 0; BrickIndex < BricksAtCurrentDepth.Num(); BrickIndex++)
			{
				const FImportedVolumetricLightmapBrick& Brick = *BricksAtCurrentDepth[BrickIndex];

				FGuid LevelGuid;

				// assign to proper data container
				if (CurrentDepth == VolumetricLightmapSettings.MaxRefinementLevels - 1)
				{
					if (bSplitToVLMCellGrid)
					{
						LevelGuid = System.LightingContext.GetLevelGuidForVLMBrick(Brick.IndirectionTexturePosition);
						const_cast<FImportedVolumetricLightmapBrick&>(Brick).IntersectingLevelGuid = LevelGuid;	// change the level guid for this brick, I use a const cast since it preserves the intent everywhere else
					}
                    else
                    {
						LevelGuid = Brick.IntersectingLevelGuid;
                    }
				}
				else
				{
					// Top level bricks are put into persistent level
					LevelGuid = PersistentLevelGuid;
				}

				if (!SubLevelTotalBricks.Contains(LevelGuid))
				{
					SubLevelTotalBricks.Add(LevelGuid, 0);
					SubLevelBrickAllocator.Add(LevelGuid, 0);
					SubLevelBrickLayoutDimensions.Add(LevelGuid, FIntVector(0));
				}

				SubLevelTotalBricks[LevelGuid]++;
			}
		}

		for (auto Pair : SubLevelTotalBricks)
		{
			bool bPersistentLevel = Pair.Key == FGuid();

			FIntVector& SubLevelBrickLayoutDimension = SubLevelBrickLayoutDimensions[Pair.Key];
			int32 SubLevelBrickTextureLinearAllocator = SubLevelTotalBricks[Pair.Key];
			SubLevelBrickLayoutDimension.X = FMath::Min(SubLevelBrickTextureLinearAllocator, MaxBricksInLayoutOneDim);
			SubLevelBrickTextureLinearAllocator = FMath::DivideAndRoundUp(SubLevelBrickTextureLinearAllocator, SubLevelBrickLayoutDimension.X);
			SubLevelBrickLayoutDimension.Y = FMath::Min(SubLevelBrickTextureLinearAllocator, MaxBricksInLayoutOneDim);
			SubLevelBrickTextureLinearAllocator = FMath::DivideAndRoundUp(SubLevelBrickTextureLinearAllocator, SubLevelBrickLayoutDimension.Y);
			SubLevelBrickLayoutDimension.Z = FMath::Min(SubLevelBrickTextureLinearAllocator, MaxBricksInLayoutOneDim);

			{
				FPrecomputedVolumetricLightmapData& SubLevelData =  System.LightingContext.GetOrCreateLevelPrecomputedVolumetricLightmapBuildData(Pair.Key);

				SubLevelData.InitializeOnImport(FBox(VolumetricLightmapSettings.VolumeMin, VolumetricLightmapSettings.VolumeMin + VolumetricLightmapSettings.VolumeSize), BrickSize);
				{
					// Temporarily assign format as PF_B8G8R8A8 since that matches FColor and makes our operations easier
					// Will be converted to PF_R8G8B8A8 by ConvertBGRA8ToRGBA8ForLayer() later
					SubLevelData.BrickData.AmbientVector.Format = PF_FloatR11G11B10;
					SubLevelData.BrickData.SkyBentNormal.Format = PF_B8G8R8A8;
					SubLevelData.BrickData.DirectionalLightShadowing.Format = PF_G8;

					for (int32 i = 0; i < UE_ARRAY_COUNT(SubLevelData.BrickData.SHCoefficients); i++)
					{
						SubLevelData.BrickData.SHCoefficients[i].Format = PF_B8G8R8A8;
					}
				}

				SubLevelData.BrickDataDimensions = SubLevelBrickLayoutDimension * PaddedBrickSize;
				const int32 TotalBrickDataSize = SubLevelData.BrickDataDimensions.X * SubLevelData.BrickDataDimensions.Y * SubLevelData.BrickDataDimensions.Z;

				SubLevelData.BrickData.AmbientVector.Resize(TotalBrickDataSize * GPixelFormats[SubLevelData.BrickData.AmbientVector.Format].BlockBytes);

				if (bGenerateSkyShadowing)
				{
					SubLevelData.BrickData.SkyBentNormal.Resize(TotalBrickDataSize * GPixelFormats[SubLevelData.BrickData.SkyBentNormal.Format].BlockBytes);
				}

				SubLevelData.BrickData.DirectionalLightShadowing.Resize(TotalBrickDataSize * GPixelFormats[SubLevelData.BrickData.DirectionalLightShadowing.Format].BlockBytes);

				for (int32 i = 0; i < UE_ARRAY_COUNT(SubLevelData.BrickData.SHCoefficients); i++)
				{
					const int32 Stride = GPixelFormats[SubLevelData.BrickData.SHCoefficients[i].Format].BlockBytes;
					SubLevelData.BrickData.SHCoefficients[i].Resize(TotalBrickDataSize * Stride);
				}
			}
		}

		BrickStartAllocation = 0;

		for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
		{
			const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];

			for (int32 BrickIndex = 0; BrickIndex < BricksAtCurrentDepth.Num(); BrickIndex++)
			{
				const FImportedVolumetricLightmapBrick& Brick = *BricksAtCurrentDepth[BrickIndex];

				FGuid LevelGuid;

				if (CurrentDepth == VolumetricLightmapSettings.MaxRefinementLevels - 1)
				{
					LevelGuid = Brick.IntersectingLevelGuid;
				}
				else
				{
					// Top level bricks are put into persistent level
					LevelGuid = PersistentLevelGuid;
				}

				FPrecomputedVolumetricLightmapData& SubLevelData =  System.LightingContext.GetOrCreateLevelPrecomputedVolumetricLightmapBuildData(LevelGuid);

				const FIntVector BrickLayoutPosition = ComputeBrickLayoutPosition(BrickStartAllocation + BrickIndex, BrickLayoutDimensions) * PaddedBrickSize;
				const FIntVector SubLevelBrickLayoutPosition = ComputeBrickLayoutPosition(SubLevelBrickAllocator[LevelGuid], SubLevelBrickLayoutDimensions[LevelGuid]) * PaddedBrickSize;

				CopyBetweenAtlasVolumeTextures(
					GPixelFormats[CurrentLevelData.BrickData.AmbientVector.Format].BlockBytes,
					FIntVector(PaddedBrickSize),
					CurrentLevelData.BrickDataDimensions,
					BrickLayoutPosition,
					CurrentLevelData.BrickData.AmbientVector.Data,
					SubLevelBrickLayoutDimensions[LevelGuid] * PaddedBrickSize,
					SubLevelBrickLayoutPosition,
					SubLevelData.BrickData.AmbientVector.Data);

				for (int32 i = 0; i < UE_ARRAY_COUNT(Brick.SHCoefficients); i++)
				{
					CopyBetweenAtlasVolumeTextures(
						GPixelFormats[CurrentLevelData.BrickData.SHCoefficients[i].Format].BlockBytes,
						FIntVector(PaddedBrickSize),
						CurrentLevelData.BrickDataDimensions,
						BrickLayoutPosition,
						CurrentLevelData.BrickData.SHCoefficients[i].Data,
						SubLevelBrickLayoutDimensions[LevelGuid] * PaddedBrickSize,
						SubLevelBrickLayoutPosition,
						SubLevelData.BrickData.SHCoefficients[i].Data);
				}

				if (bGenerateSkyShadowing)
				{
					CopyBetweenAtlasVolumeTextures(
						GPixelFormats[CurrentLevelData.BrickData.SkyBentNormal.Format].BlockBytes,
						FIntVector(PaddedBrickSize),
						CurrentLevelData.BrickDataDimensions,
						BrickLayoutPosition,
						CurrentLevelData.BrickData.SkyBentNormal.Data,
						SubLevelBrickLayoutDimensions[LevelGuid] * PaddedBrickSize,
						SubLevelBrickLayoutPosition,
						SubLevelData.BrickData.SkyBentNormal.Data);
				}

				CopyBetweenAtlasVolumeTextures(
					GPixelFormats[CurrentLevelData.BrickData.DirectionalLightShadowing.Format].BlockBytes,
					FIntVector(PaddedBrickSize),
					CurrentLevelData.BrickDataDimensions,
					BrickLayoutPosition,
					CurrentLevelData.BrickData.DirectionalLightShadowing.Data,
					SubLevelBrickLayoutDimensions[LevelGuid] * PaddedBrickSize,
					SubLevelBrickLayoutPosition,
					SubLevelData.BrickData.DirectionalLightShadowing.Data);

				SubLevelBrickAllocator[LevelGuid]++;

				if (LevelGuid != PersistentLevelGuid)
				{
					SubLevelData.SubLevelBrickPositions.Add(Brick.IndirectionTexturePosition);
					check(SubLevelData.SubLevelBrickPositions.Num() == SubLevelBrickAllocator[LevelGuid]);
				}
			}

			BrickStartAllocation += BricksAtCurrentDepth.Num();
		}

		{
			const int32 TotalIndirectionTextureSize = CurrentLevelData.IndirectionTextureDimensions.X * CurrentLevelData.IndirectionTextureDimensions.Y * CurrentLevelData.IndirectionTextureDimensions.Z;
			CurrentLevelData.IndirectionTexture.Resize(TotalIndirectionTextureSize * IndirectionTextureDataStride);
			BuildIndirectionTexture(BricksByDepth, VolumetricLightmapSettings, MaxBricksInLayoutOneDim, SubLevelBrickLayoutDimensions[FGuid()], IndirectionTextureDataStride, CurrentLevelData, true);

			FPrecomputedVolumetricLightmapData& PersistentLevelData =  System.LightingContext.GetOrCreateLevelPrecomputedVolumetricLightmapBuildData(PersistentLevelGuid);

			PersistentLevelData.InitializeOnImport(FBox(VolumetricLightmapSettings.VolumeMin, VolumetricLightmapSettings.VolumeMin + VolumetricLightmapSettings.VolumeSize), BrickSize);
			PersistentLevelData.IndirectionTexture = CurrentLevelData.IndirectionTexture;
			PersistentLevelData.IndirectionTextureDimensions = CurrentLevelData.IndirectionTextureDimensions;
		}

		{
			for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
			{
				const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];

				for (int32 BrickIndex = 0; BrickIndex < BricksAtCurrentDepth.Num(); BrickIndex++)
				{
					const FImportedVolumetricLightmapBrick& Brick = *BricksAtCurrentDepth[BrickIndex];

					FGuid LevelGuid;

					if (CurrentDepth == VolumetricLightmapSettings.MaxRefinementLevels - 1)
					{
						LevelGuid = Brick.IntersectingLevelGuid;
					}
					else
					{
						// Top level bricks are put into persistent level
						LevelGuid = PersistentLevelGuid;
					}

					if (LevelGuid != PersistentLevelGuid)
					{
						FPrecomputedVolumetricLightmapData& SubLevelData =  System.LightingContext.GetOrCreateLevelPrecomputedVolumetricLightmapBuildData(LevelGuid);

						FIntVector IndirectionBrickOffset;
						int32 IndirectionBrickSize;
						const FVector IndirectionDataSourceCoordinate = FVector(Brick.IndirectionTexturePosition) + FVector(0.5f, 0.5f, 0.5f);
						SampleIndirectionTexture(IndirectionDataSourceCoordinate, CurrentLevelData.IndirectionTextureDimensions, CurrentLevelData.IndirectionTexture.Data.GetData(), IndirectionBrickOffset, IndirectionBrickSize);

						SubLevelData.IndirectionTextureOriginalValues.Add(FColor((uint8)IndirectionBrickOffset.X, (uint8)IndirectionBrickOffset.Y, (uint8)IndirectionBrickOffset.Z, (uint8)IndirectionBrickSize));
					}
				}
			}

		}

		{
			for (auto Pair : SubLevelTotalBricks)
			{
				FGuid LevelGuid = Pair.Key;

				FPrecomputedVolumetricLightmapData& SubLevelData =  System.LightingContext.GetOrCreateLevelPrecomputedVolumetricLightmapBuildData(LevelGuid);

				ConvertBGRA8ToRGBA8ForLayer(SubLevelData.BrickData.SkyBentNormal);

				for (int32 i = 0; i < UE_ARRAY_COUNT(SubLevelData.BrickData.SHCoefficients); i++)
				{
					ConvertBGRA8ToRGBA8ForLayer(SubLevelData.BrickData.SHCoefficients[i]);
				}
			}
		}
	}

	{
		/**
		 * Statistics
		 */

		double ImportTime = FPlatformTime::Seconds() - StartTime;
		UE_LOG(LogVolumetricLightmapImport, Log, TEXT("Imported Volumetric Lightmap in %.3fs"), ImportTime);
		UE_LOG(LogVolumetricLightmapImport, Log, TEXT("     Indirection Texture %ux%ux%u = %.1fMb"),
			CurrentLevelData.IndirectionTextureDimensions.X,
			CurrentLevelData.IndirectionTextureDimensions.Y,
			CurrentLevelData.IndirectionTextureDimensions.Z,
			CurrentLevelData.IndirectionTexture.Data.Num() / 1024.0f / 1024.0f);

		uint64 BrickDataSize = 0;

		for (auto Pair : SubLevelTotalBricks)
		{
			FPrecomputedVolumetricLightmapData& SubLevelData =  System.LightingContext.GetOrCreateLevelPrecomputedVolumetricLightmapBuildData(Pair.Key);

			SubLevelData.FinalizeImport();

			check(SubLevelData.IndirectionTextureOriginalValues.Num() == SubLevelData.SubLevelBrickPositions.Num());

			BrickDataSize += 
				SubLevelData.BrickData.AmbientVector.Data.Num() + 
				SubLevelData.BrickData.SHCoefficients[0].Data.Num() + 
				SubLevelData.BrickData.SHCoefficients[1].Data.Num() + 
				SubLevelData.BrickData.SHCoefficients[2].Data.Num() + 
				SubLevelData.BrickData.SHCoefficients[3].Data.Num() + 
				SubLevelData.BrickData.SHCoefficients[4].Data.Num() + 
				SubLevelData.BrickData.SHCoefficients[5].Data.Num() + 
				SubLevelData.BrickData.SkyBentNormal.Data.Num() + 
				SubLevelData.BrickData.DirectionalLightShadowing.Data.Num() +
				SubLevelData.SubLevelBrickPositions.Num() * SubLevelData.SubLevelBrickPositions.GetTypeSize() +
				SubLevelData.IndirectionTextureOriginalValues.Num() * SubLevelData.IndirectionTextureOriginalValues.GetTypeSize();
		}

		if (bSplitToVLMCellGrid)
		{
			// Export the data			
			FVolumetricLightMapGridDesc& GridDesc = *System.LightingContext.GetVolumetricLightMapGridDesc();
			GridDesc.InitializeBulkData();
		}

		int32 TotalNumBricks = 0;

		for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
		{
			const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];
			TotalNumBricks += BricksAtCurrentDepth.Num();
		}

		const uint64 ActualBrickSizeBytes = BrickDataSize / TotalNumBricks;

		FString TrimmedString;

		if (NumBottomLevelBricksTrimmedByInterpolationError > 0)
		{
			TrimmedString += FString::Printf(TEXT(" (trimmed %.1fMb due to %f MinBrickError)"),
				NumBottomLevelBricksTrimmedByInterpolationError * ActualBrickSizeBytes / 1024.0f / 1024.0f,
				VolumetricLightmapSettings.MinBrickError);
		}

		if (NumBottomLevelBricksTrimmedForMemoryLimit > 0)
		{
			TrimmedString += FString::Printf(TEXT(" (trimmed %.1fMb due to %.1fMb MaximumBrickMemoryMb)"),
				NumBottomLevelBricksTrimmedForMemoryLimit * ActualBrickSizeBytes / 1024.0f / 1024.0f,
				MaximumBrickMemoryMb);
		}

		UE_LOG(LogVolumetricLightmapImport, Log, TEXT("     BrickData (all levels) %.1fMb%s"),
			BrickDataSize / 1024.0f / 1024.0f,
			*TrimmedString);

		UE_LOG(LogVolumetricLightmapImport, Log, TEXT("     Bricks at depth"));

		const float TotalVolume = VolumetricLightmapSettings.VolumeSize.X * VolumetricLightmapSettings.VolumeSize.Y * VolumetricLightmapSettings.VolumeSize.Z;

		for (int32 CurrentDepth = 0; CurrentDepth < VolumetricLightmapSettings.MaxRefinementLevels; CurrentDepth++)
		{
			const int32 DetailCellsPerCurrentLevelBrick = 1 << ((VolumetricLightmapSettings.MaxRefinementLevels - CurrentDepth) * BrickSizeLog2);
			const FVector CurrentDepthBrickSize = DetailCellSize * DetailCellsPerCurrentLevelBrick;
			const TArray<const FImportedVolumetricLightmapBrick*>& BricksAtCurrentDepth = BricksByDepth[CurrentDepth];
			const double CurrentDepthBrickVolume = CurrentDepthBrickSize.X * CurrentDepthBrickSize.Y * CurrentDepthBrickSize.Z;

			UE_LOG(LogVolumetricLightmapImport, Log, TEXT("         %u: %.1f%% covering %.1f%% of volume"),
				CurrentDepth,
				100.0f * BricksAtCurrentDepth.Num() / TotalNumBricks,
				100.0f * BricksAtCurrentDepth.Num() * CurrentDepthBrickVolume / TotalVolume);
		}

		UE_LOG(LogVolumetricLightmapImport, Log, TEXT("     Bricks in each level"));

		for (auto Pair : SubLevelTotalBricks)
		{
			ULevel* Level = FindLevel(Pair.Key);
			FString LevelName;
			if (Level)
			{
				LevelName = Level->GetOuter()->GetName();
			}
			else
			{				
				LevelName = System.LightingContext.GetVolumetricLightMapGridDesc()->GetCellDesc(Pair.Key);
			}

			if (Level && Level->IsPersistentLevel())
			{
				UE_LOG(LogVolumetricLightmapImport, Log, TEXT("         %s \t\t\t %d bricks \t %.1f%% (Persistent Level)"), *LevelName, Pair.Value, 100.0f * Pair.Value / TotalNumBricks);
			}
			else
			{
				UE_LOG(LogVolumetricLightmapImport, Log, TEXT("         %s \t\t\t %d bricks \t %.1f%%"), *LevelName, Pair.Value, 100.0f * Pair.Value / TotalNumBricks);
			}
		}
	}
}

#undef LOCTEXT_NAMESPACE