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

/*=============================================================================
	Lightmass.h: lightmass import/export implementation.
=============================================================================*/

#include "Lightmass/Lightmass.h"
#include "HAL/FileManager.h"
#include "Misc/Paths.h"
#include "Misc/ScopeLock.h"
#include "Misc/ConfigCacheIni.h"
#include "Misc/FeedbackContext.h"
#include "Misc/App.h"
#include "UObject/UObjectIterator.h"
#include "EngineDefines.h"
#include "Engine/World.h"
#include "StaticMeshLight.h"
#include "PrecomputedLightVolume.h"
#include "PrecomputedVolumetricLightmap.h"
#include "Engine/MapBuildDataRegistry.h"
#include "Engine/TextureLightProfile.h"
#include "ModelLight.h"
#include "LandscapeLight.h"
#include "MaterialDomain.h"
#include "Materials/Material.h"
#include "Camera/CameraActor.h"
#include "Components/PointLightComponent.h"
#include "Components/SpotLightComponent.h"
#include "Components/RectLightComponent.h"
#include "Engine/GeneratedMeshAreaLight.h"
#include "Components/DirectionalLightComponent.h"
#include "Components/SkyLightComponent.h"
#include "Rendering/SkyAtmosphereCommonData.h"
#include "Components/ModelComponent.h"
#include "Materials/MaterialInstanceConstant.h"
#include "EngineUtils.h"
#include "Editor.h"
#include "LevelEditorViewport.h"
#include "StaticMeshResources.h"
#include "LightMap.h"
#include "ShadowMap.h"
#include "LandscapeProxy.h"
#include "LandscapeComponent.h"
#include "Components/SplineMeshComponent.h"
#include "Lightmass/PrecomputedVisibilityVolume.h"
#include "Lightmass/PrecomputedVisibilityOverrideVolume.h"
#include "ComponentReregisterContext.h"
#include "ShaderCompiler.h"
#include "Engine/LevelStreaming.h"
#include "UnrealEngine.h"
#include "ComponentRecreateRenderStateContext.h"
#include "EditorLevelUtils.h"
#include "Misc/MessageDialog.h"
#include "Modules/ModuleManager.h"
#include "ImageCoreUtils.h"
#include "Misc/FileHelper.h"
#include "StaticLightingBuildContext.h"
#include "Engine/InstancedStaticMesh.h"

extern FSwarmDebugOptions GSwarmDebugOptions;

//@todo_ow: Potentially move to core for sharing ?
class FObjectMemoryWriter : public  FMemoryWriter 
{
public:
	FObjectMemoryWriter(TArray<uint8>& Payload) : 
		FMemoryWriter(Payload)
	{
	}

	virtual FArchive& operator<<(struct FSoftObjectPath& Value)
	{
		FString FullPath = Value.ToString();
		*this << FullPath;

		return *this;
	}
};

class FObjectMemoryReader : public  FMemoryReader
{
public:
	FObjectMemoryReader(TArray<uint8>& Payload) :
		FMemoryReader(Payload)
	{
	}

	virtual FArchive& operator<<(struct FSoftObjectPath& Value)
	{
		FString FullPath;
		*this << FullPath;
		Value = FSoftObjectPath(FullPath);

		return *this;
	}
};

struct FDeferredMappingsBundle
{
	// Map of all external GUIDs to internal mapping GUID in this bundle 
	// This is used to map the owners actors to the mappings
	TMap<FGuid, FGuid> OwnerToMapping;
	TMap<FGuid, const FLightmassProcessor::FTextureMappingImportHelper*> MappingGuidToHelper;
	TArray<FLightmassProcessor::FTextureMappingImportHelper> Mappings;
	
	void Serialize(FArchive& Ar, bool bManifestOnly)
	{
		Ar << OwnerToMapping;
		
		if (!bManifestOnly)
		{
			Ar << Mappings;
		}

	}

	void MapHelpers()
	{
		MappingGuidToHelper.Reset();
		OwnerToMapping.Reset();

		for (const FLightmassProcessor::FTextureMappingImportHelper& Helper : Mappings)
		{
			MappingGuidToHelper.Add(Helper.MappingGuid, &Helper);
			OwnerToMapping.Add(Helper.OwnerGuid, Helper.MappingGuid);
		}
	}
};




DEFINE_LOG_CATEGORY_STATIC(LogLightmassSolver, Warning, All);
/**
 * If false (default behavior), Lightmass is launched automatically when a lighting build starts.
 * If true, it must be launched manually (e.g. through a debugger).
 */
UNREALED_API bool GLightmassDebugMode = false; 

/** If true, all participating Lightmass agents will report back detailed stats to the log. */
UNREALED_API bool GLightmassStatsMode = false;

/*-----------------------------------------------------------------------------
	FSwarmDebugOptions
-----------------------------------------------------------------------------*/
// Doxygen cannot parse this since FSwarmDebugOptions is declared in an engine header
#if !UE_BUILD_DOCS
void FSwarmDebugOptions::Touch()
{
	//@todo For some reason, the global instance is not initializing to the default settings...
	if (bInitialized == false)
	{
		bDistributionEnabled = true;
		bForceContentExport = false;

		bInitialized = true;
	}
}
#endif

#include "ImportExport.h"
#include "MaterialExport.h"
#include "StatsViewerModule.h"
#include "LightingBuildInfo.h"
#include "Logging/TokenizedMessage.h"
#include "Logging/MessageLog.h"
#include "Misc/UObjectToken.h"

#define LOCTEXT_NAMESPACE "Lightmass"

/** The number of available mappings to process before yielding back to the importing. */
int32 FLightmassProcessor::MaxProcessAvailableCount = 8;

/** We don't want any amortization steps to take longer than this amount every tick */
static const float AllowedAmortizationTimePerTick = 0.01f; // in seconds

volatile int32 FLightmassProcessor::VolumeSampleTaskCompleted = 0;
volatile int32 FLightmassProcessor::MeshAreaLightDataTaskCompleted = 0;
volatile int32 FLightmassProcessor::VolumeDistanceFieldTaskCompleted = 0;

/** Flags to use when opening the different kinds of input channels */
/** MUST PAIR APPROPRIATELY WITH THE SAME FLAGS IN LIGHTMASS */
static NSwarm::TChannelFlags LM_TEXTUREMAPPING_CHANNEL_FLAGS	= NSwarm::SWARM_JOB_CHANNEL_READ;
static NSwarm::TChannelFlags LM_VERTEXMAPPING_CHANNEL_FLAGS		= NSwarm::SWARM_JOB_CHANNEL_READ;
static NSwarm::TChannelFlags LM_VOLUMESAMPLES_CHANNEL_FLAGS		= NSwarm::SWARM_JOB_CHANNEL_READ;
static NSwarm::TChannelFlags LM_PRECOMPUTEDVISIBILITY_CHANNEL_FLAGS	= NSwarm::SWARM_JOB_CHANNEL_READ;
static NSwarm::TChannelFlags LM_VOLUMEDEBUGOUTPUT_CHANNEL_FLAGS	= NSwarm::SWARM_JOB_CHANNEL_READ;
static NSwarm::TChannelFlags LM_DOMINANTSHADOW_CHANNEL_FLAGS	= NSwarm::SWARM_JOB_CHANNEL_READ;
static NSwarm::TChannelFlags LM_MESHAREALIGHT_CHANNEL_FLAGS		= NSwarm::SWARM_JOB_CHANNEL_READ;
static NSwarm::TChannelFlags LM_DEBUGOUTPUT_CHANNEL_FLAGS		= NSwarm::SWARM_JOB_CHANNEL_READ;

/** Flags to use when opening the different kinds of output channels */
/** MUST PAIR APPROPRIATELY WITH THE SAME FLAGS IN LIGHTMASS */
#if LM_COMPRESS_INPUT_DATA
	static NSwarm::TChannelFlags LM_SCENE_CHANNEL_FLAGS			= (NSwarm::TChannelFlags)(NSwarm::SWARM_JOB_CHANNEL_WRITE | NSwarm::SWARM_CHANNEL_MISC_ENABLE_COMPRESSION);
	static NSwarm::TChannelFlags LM_STATICMESH_CHANNEL_FLAGS	= (NSwarm::TChannelFlags)(NSwarm::SWARM_CHANNEL_WRITE | NSwarm::SWARM_CHANNEL_MISC_ENABLE_COMPRESSION);
	static NSwarm::TChannelFlags LM_TERRAIN_CHANNEL_FLAGS		= (NSwarm::TChannelFlags)(NSwarm::SWARM_CHANNEL_WRITE | NSwarm::SWARM_CHANNEL_MISC_ENABLE_COMPRESSION);
	static NSwarm::TChannelFlags LM_MATERIAL_CHANNEL_FLAGS		= (NSwarm::TChannelFlags)(NSwarm::SWARM_CHANNEL_WRITE | NSwarm::SWARM_CHANNEL_MISC_ENABLE_COMPRESSION);
#else
	static NSwarm::TChannelFlags LM_SCENE_CHANNEL_FLAGS			= NSwarm::SWARM_JOB_CHANNEL_WRITE;
	static NSwarm::TChannelFlags LM_STATICMESH_CHANNEL_FLAGS	= NSwarm::SWARM_CHANNEL_WRITE;
	static NSwarm::TChannelFlags LM_TERRAIN_CHANNEL_FLAGS		= NSwarm::SWARM_CHANNEL_WRITE;
	static NSwarm::TChannelFlags LM_MATERIAL_CHANNEL_FLAGS		= NSwarm::SWARM_CHANNEL_WRITE;
#endif
	
#define VERIFYLIGHTMASSINI(x)			{bool bSucceeded = x; if (!bSucceeded) { VerifyLightmassIni(#x,__FILE__,__LINE__); }}

void VerifyLightmassIni(const ANSICHAR* Code,const ANSICHAR* Filename,uint32 Line)
{
	if (FApp::IsUnattended())
	{
		UE_LOG(LogLightmassSolver, Fatal,TEXT("%s failed \n at %s:%u"),ANSI_TO_TCHAR(Code),ANSI_TO_TCHAR(Filename),Line);
	}
	else
	{
		FString Error = FString::Printf(
			TEXT("Fatal error: A required key was missing from BaseLightmass.ini.  This can happen if BaseLightmass.ini is overwritten with an old version.\n")
			TEXT("Create a DefaultLightmass.ini in your project and override just the values you need, then the overrides will continue to work on version upgrades.\n")
			TEXT("https://docs.unrealengine.com/latest/INT/Programming/Basics/ConfigurationFiles\n\n")
			TEXT("%s failed \n at %s:%u"),
			ANSI_TO_TCHAR(Code),ANSI_TO_TCHAR(Filename),Line);
		FMessageDialog::Open(EAppMsgType::Ok, FText::FromString(Error));
		FPlatformMisc::RequestExit(1);
	}
}

/*-----------------------------------------------------------------------------
	FLightmassExporter
-----------------------------------------------------------------------------*/


void Copy( const ULightComponentBase* In, Lightmass::FLightData& Out )
{	
	FMemory::Memzero(Out);

	Out.LightFlags = 0;
	if (In->CastShadows)
	{
		Out.LightFlags |= Lightmass::GI_LIGHT_CASTSHADOWS;
	}

	if (In->HasStaticLighting())
	{
		Out.LightFlags |= Lightmass::GI_LIGHT_HASSTATICSHADOWING;
		Out.LightFlags |= Lightmass::GI_LIGHT_HASSTATICLIGHTING;
	}
	else if (In->HasStaticShadowing())
	{
		Out.LightFlags |= Lightmass::GI_LIGHT_STORE_SEPARATE_SHADOW_FACTOR;
		Out.LightFlags |= Lightmass::GI_LIGHT_HASSTATICSHADOWING;
	}

	if (In->CastStaticShadows)
	{
		Out.LightFlags |= Lightmass::GI_LIGHT_CASTSTATICSHADOWS;
	}

	Out.Color = In->LightColor;

	// Set brightness here for light types that only derive from ULightComponentBase and not from ULightComponent
	Out.Brightness = In->Intensity;
	Out.Guid = In->LightGuid;
	Out.IndirectLightingScale = In->IndirectLightingIntensity;
}

void Copy( const ULightComponent* In, Lightmass::FLightData& Out )
{	
	Copy((const ULightComponentBase*)In, Out);

	const ULocalLightComponent* LocalLight = Cast<const ULocalLightComponent>(In);
	const UPointLightComponent* PointLight = Cast<const UPointLightComponent>(In);

	if( ( LocalLight && LocalLight->GetLightType() == LightType_Rect ) ||
		( PointLight && PointLight->bUseInverseSquaredFalloff ) )
	{
		Out.LightFlags |= Lightmass::GI_LIGHT_INVERSE_SQUARED;
	}

	if (In->GetLightmassSettings().bUseAreaShadowsForStationaryLight)
	{
		Out.LightFlags |= Lightmass::GI_LIGHT_USE_AREA_SHADOWS_FOR_SEPARATE_SHADOW_FACTOR;
	}

	Out.Brightness = In->ComputeLightBrightness();
	Out.Position = (FVector4f)In->GetLightPosition();
	Out.Direction = (FVector3f)In->GetDirection();

	if( In->bUseTemperature )
	{
		Out.Color *= In->GetColorTemperature();
	}
}

void CopyLightProfile( const ULightComponentBase* In, Lightmass::FLightData& Out, TArray< uint8 >& OutLightProfileTextureData )
{
	OutLightProfileTextureData.Empty( Lightmass::FLightData::LightProfileTextureDataSize );
	OutLightProfileTextureData.AddUninitialized( Lightmass::FLightData::LightProfileTextureDataSize );

	FMemory::Memset(OutLightProfileTextureData.GetData(), 0xff, OutLightProfileTextureData.Num() * OutLightProfileTextureData.GetTypeSize());
}

void CopyLightProfile( const ULightComponent* In, Lightmass::FLightData& Out, TArray< uint8 >& OutLightProfileTextureData )
{
	CopyLightProfile( (const ULightComponentBase*)In, Out, OutLightProfileTextureData );

	if(In->IESTexture)
	{
		FTextureSource& Source = In->IESTexture->Source;

		// The current IES importer only uses this input format
		// even if we change the actual texture format this shouldn't change
		if( Source.GetFormat() == TSF_RGBA16F &&
			Source.GetSizeX() * Source.GetSizeY() <= Lightmass::FLightData::LightProfileTextureDataSize )
		{
			Out.LightFlags |= Lightmass::GI_LIGHT_USE_LIGHTPROFILE;

			TArray64<uint8> MipData;

			verify( Source.GetMipData(MipData, 0) );

			const uint32 Width = FMath::Sqrt( static_cast<float>(Lightmass::FLightData::LightProfileTextureDataSize) );
			const uint32 Height = Lightmass::FLightData::LightProfileTextureDataSize / Width;

			for(uint32 y = 0; y < Height; ++y)
			{
				uint32 SourceY = FMath::Min( y, (uint32)Source.GetSizeY() - 1 ); // We'll repeat the data if the source is smaller than the destination (we used to have 1D textures for IES files)

				for(uint32 x = 0; x < Width; ++x)
				{
					uint32 SourceX = FMath::Min( x, (uint32)Source.GetSizeX() - 1 );

					FFloat16 HalfValue = *(FFloat16*)&MipData[ (SourceY * (uint32)Source.GetSizeX() * 8) + (SourceX * 8) ];
					float Value = HalfValue;
					OutLightProfileTextureData[y * Width + x] = (uint8)(Value * 255.f + 0.5f);
				}
			}
		}
	}
}

FORCEINLINE void Copy( const FSplineMeshParams& In, Lightmass::FSplineMeshParams& Out )
{
	Out.StartPos = FVector3f(In.StartPos);	//LWC_TODO: Precision loss
	Out.StartTangent = FVector3f(In.StartTangent);
	Out.StartScale = FVector2f(In.StartScale);	// LWC_TODO: Precision loss
	Out.StartRoll = In.StartRoll;
	Out.StartOffset = FVector2f(In.StartOffset);	// LWC_TODO: Precision loss
	Out.EndPos = FVector3f(In.EndPos);	//LWC_TODO: Precision loss
	Out.EndTangent = FVector3f(In.EndTangent);
	Out.EndScale = FVector2f(In.EndScale);	// LWC_TODO: Precision loss
	Out.EndOffset = FVector2f(In.EndOffset);	// LWC_TODO: Precision loss
	Out.EndRoll = In.EndRoll;
}

void FLightmassProcessor::ProcessAlertMessages()
{
	FScopeLock Lock(&SwarmCallbackMessagesSection);

	for (int32 MessageIndex = 0; MessageIndex < SwarmCallbackMessages.Num(); MessageIndex++)
	{
		FLightmassAlertMessage& AlertMessage = SwarmCallbackMessages[MessageIndex];

		UObject* Object = NULL;

		switch (AlertMessage.Type)
		{
		case Lightmass::SOURCEOBJECTTYPE_StaticMesh:
			Object = FindStaticMesh(AlertMessage.ObjectId);
			break;
		case Lightmass::SOURCEOBJECTTYPE_Mapping:
			const FStaticLightingMapping* FoundMapping = GetLightmassExporter()->FindMappingByGuid(AlertMessage.ObjectId);
			if (FoundMapping)
			{
				Object = FoundMapping->GetMappedObject();
			}
			break;
		}

		FText LocalizedMessage;
		const FText* LocalizedMessagePtr = Messages.Find( FString( AlertMessage.MessageText ) );
		if ( LocalizedMessagePtr == NULL )
		{
			LocalizedMessage = FText::FromString( FString( AlertMessage.MessageText ) );
			LocalizedMessagePtr = &LocalizedMessage;
		}

		FMessageLog("LightingResults").Message((EMessageSeverity::Type)AlertMessage.Severity)
			->AddToken(FUObjectToken::Create(Object))
			->AddToken(FTextToken::Create( *LocalizedMessagePtr ));
	}

	SwarmCallbackMessages.Empty();
}

/*-----------------------------------------------------------------------------
	SwarmCallback function
-----------------------------------------------------------------------------*/
void FLightmassProcessor::SwarmCallback( NSwarm::FMessage* CallbackMessage, void* CallbackData )
{
	FLightmassProcessor* Processor = (FLightmassProcessor*) CallbackData;
	double SwarmCallbackStartTime = FPlatformTime::Seconds();

	switch ( CallbackMessage->Type )
	{
		case NSwarm::MESSAGE_JOB_STATE:
		{
			NSwarm::FJobState* JobStateMessage = (NSwarm::FJobState*)CallbackMessage;
			switch (JobStateMessage->JobState)
			{
				case NSwarm::JOB_STATE_INVALID:
					Processor->bProcessingFailed = true;
					break;
				case NSwarm::JOB_STATE_RUNNING:
					break;
				case NSwarm::JOB_STATE_COMPLETE_SUCCESS:
					Processor->bProcessingSuccessful = true;
					break;
				case NSwarm::JOB_STATE_COMPLETE_FAILURE:
					Processor->bProcessingFailed = true;
					break;
				case NSwarm::JOB_STATE_KILLED:
					Processor->bProcessingFailed = true;
					break;
				default:
					break;
			}
		}
		break;

		case NSwarm::MESSAGE_TASK_STATE:
		{
			NSwarm::FTaskState* TaskStateMessage = (NSwarm::FTaskState*)CallbackMessage;
			switch (TaskStateMessage->TaskState)
			{
				case NSwarm::JOB_TASK_STATE_INVALID:
					// Consider this cause for failing the entire Job
					Processor->bProcessingFailed = true;
					break;
				case NSwarm::JOB_TASK_STATE_ACCEPTED:
					break;
				case NSwarm::JOB_TASK_STATE_REJECTED:
					// Consider this cause for failing the entire Job
					Processor->bProcessingFailed = true;
					break;
				case NSwarm::JOB_TASK_STATE_RUNNING:
					break;
				case NSwarm::JOB_TASK_STATE_COMPLETE_SUCCESS:
				{
					FGuid PrecomputedVolumeLightingGuid = Lightmass::PrecomputedVolumeLightingGuid;
					FGuid MeshAreaLightDataGuid = Lightmass::MeshAreaLightDataGuid;
					FGuid VolumeDistanceFieldGuid = Lightmass::VolumeDistanceFieldGuid;
					if (TaskStateMessage->TaskGuid == PrecomputedVolumeLightingGuid)
					{
						FPlatformAtomics::InterlockedIncrement( &VolumeSampleTaskCompleted );
						FPlatformAtomics::InterlockedIncrement( &Processor->NumCompletedTasks );
					}
					else if (Processor->Exporter->VisibilityBucketGuids.Contains(TaskStateMessage->TaskGuid))
					{
						TList<FGuid>* NewElement = new TList<FGuid>(TaskStateMessage->TaskGuid, NULL);
						Processor->CompletedVisibilityTasks.AddElement( NewElement );
						FPlatformAtomics::InterlockedIncrement( &Processor->NumCompletedTasks );
					}
					else if (Processor->Exporter->VolumetricLightmapTaskGuids.Contains(TaskStateMessage->TaskGuid))
					{
						TList<FGuid>* NewElement = new TList<FGuid>(TaskStateMessage->TaskGuid, NULL);
						Processor->CompletedVolumetricLightmapTasks.AddElement( NewElement );
						FPlatformAtomics::InterlockedIncrement( &Processor->NumCompletedTasks );
						FPlatformAtomics::InterlockedIncrement( &Processor->NumCompletedVolumetricLightmapTasks );
					}
					else if (TaskStateMessage->TaskGuid == MeshAreaLightDataGuid)
					{
						FPlatformAtomics::InterlockedIncrement( &MeshAreaLightDataTaskCompleted );
						FPlatformAtomics::InterlockedIncrement( &Processor->NumCompletedTasks );
					}
					else if (TaskStateMessage->TaskGuid == VolumeDistanceFieldGuid)
					{
						FPlatformAtomics::InterlockedIncrement( &VolumeDistanceFieldTaskCompleted );
						FPlatformAtomics::InterlockedIncrement( &Processor->NumCompletedTasks );
					}
					else
					{
						// Add a mapping to the list of mapping GUIDs that have been completed
						TList<FGuid>* NewElement = new TList<FGuid>(TaskStateMessage->TaskGuid, NULL);
						Processor->CompletedMappingTasks.AddElement( NewElement );
						FPlatformAtomics::InterlockedIncrement( &Processor->NumCompletedTasks );
					}
					break;
				}
				case NSwarm::JOB_TASK_STATE_COMPLETE_FAILURE:
				{
					// Add a mapping to the list of mapping GUIDs that have been completed
					TList<FGuid>* NewElement = new TList<FGuid>(TaskStateMessage->TaskGuid, NULL);
					Processor->CompletedMappingTasks.AddElement( NewElement );
					FPlatformAtomics::InterlockedIncrement( &Processor->NumCompletedTasks );

					// Consider this cause for failing the entire Job
					Processor->bProcessingFailed = true;

					break;
				}
				case NSwarm::JOB_TASK_STATE_KILLED:
					break;
				default:
					break;
			}
		}
		break;

		case NSwarm::MESSAGE_INFO:
		{
#if !NO_LOGGING && !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
			NSwarm::FInfoMessage* InfoMessage = (NSwarm::FInfoMessage*)CallbackMessage;
			GLog->Log( InfoMessage->TextMessage );
#endif
		}
		break;

		case NSwarm::MESSAGE_ALERT:
		{
			NSwarm::FAlertMessage* AlertMessage = (NSwarm::FAlertMessage*)CallbackMessage;
			EMessageSeverity::Type CheckType = EMessageSeverity::Info;

			switch (AlertMessage->AlertLevel)
			{
			case NSwarm::ALERT_LEVEL_INFO:	break;
			case NSwarm::ALERT_LEVEL_WARNING:			CheckType = EMessageSeverity::Warning;			break;
			case NSwarm::ALERT_LEVEL_ERROR:				CheckType = EMessageSeverity::Error;			break;
			}

			FGuid ObjectGuid = FGuid(	AlertMessage->ObjectGuid.A, 
										AlertMessage->ObjectGuid.B,
										AlertMessage->ObjectGuid.C,
										AlertMessage->ObjectGuid.D);
			
			{
				// Enqueue the message for the main thread to process, because FMessageLog isn't thread safe
				FScopeLock Lock(&Processor->SwarmCallbackMessagesSection);
				FLightmassAlertMessage NewMessage;
				NewMessage.ObjectId = ObjectGuid;
				NewMessage.MessageText = AlertMessage->TextMessage;
				NewMessage.Type = AlertMessage->TypeId;
				NewMessage.Severity = CheckType;
				Processor->SwarmCallbackMessages.Push(NewMessage);
			}
		}
		break;

		case NSwarm::MESSAGE_QUIT:
		{
			Processor->bQuitReceived = true;
		}
		break;
	}

	Processor->Statistics.SwarmCallbackTime += FPlatformTime::Seconds() - SwarmCallbackStartTime;
}

/*-----------------------------------------------------------------------------
	FLightmassExporter
-----------------------------------------------------------------------------*/
FLightmassExporter::FLightmassExporter(const FStaticLightingBuildContext& Context)
	: Swarm( NSwarm::FSwarmInterface::Get() ) 
	, SkyAtmosphereComponent(nullptr)
	, ExportStage(NotRunning)
	, CurrentAmortizationIndex(0)
	, OpenedMaterialExportChannels()
	, World( Context.World )
	, LightingContext(Context)
{
	// We must have a valid world
	check( World );

	if (GLightmassDebugOptions.bDebugMode)
	{
		SceneGuid = FGuid(0x0123, 0x4567, 0x89AB, 0xCDEF);
	}
	else
	{
		SceneGuid = FGuid::NewGuid();
	}

	// Compute the hash of UnrealLightmass executable and store it into LightmassExecutableHash
	// Guaranteed success as the executable has been checked by CheckLightmassExecutableVersion()
	TArray<uint8> Bytes;
	FFileHelper::LoadFileToArray(Bytes, *FPlatformProcess::GenerateApplicationPath(TEXT("UnrealLightmass"), EBuildConfiguration::Development));
	FSHA1::HashBuffer(&Bytes[0], Bytes.Num(), LightmassExecutableHash.Hash);
	
	ChannelName = Lightmass::CreateChannelName(SceneGuid, Lightmass::LM_SCENE_VERSION, Lightmass::LM_SCENE_EXTENSION);
}

FLightmassExporter::~FLightmassExporter()
{
	// clean up any opened channels that are opened during export
	if (ExportStage == ExportMaterials)
	{
		for (int32 i = 0; i < OpenedMaterialExportChannels.Num(); ++i)
		{
			int32 Result = Swarm.CloseChannel(OpenedMaterialExportChannels[i]);
		}
	}
	else if (ExportStage == CleanupMaterialExport)
	{
		for (int32 i = CurrentAmortizationIndex; i < OpenedMaterialExportChannels.Num(); ++i)
		{
			int32 Result = Swarm.CloseChannel(OpenedMaterialExportChannels[i]);
		}
	}
}

void FLightmassExporter::AddMaterial(UMaterialInterface* InMaterialInterface, const FStaticLightingMesh* InStaticLightingMesh /*= nullptr*/)
{
	if (InMaterialInterface)
	{
		FLightmassMaterialExportSettings ExportSettings = { InStaticLightingMesh };

		if (auto* ExistingExportSettings = MaterialExportSettings.Find(InMaterialInterface))
		{
			ensureMsgf(ExportSettings == *ExistingExportSettings, TEXT("Attempting to add the same material twice with different export settings, this is not (currently) supported"));
			return;
		}

		// Check for material texture changes...
		//@TODO: Add package to warning list if it needs to be resaved (perf warning)
		InMaterialInterface->UpdateLightmassTextureTracking();

		Materials.Add(InMaterialInterface);
		MaterialExportSettings.Add(InMaterialInterface, ExportSettings);
	}
}

const FStaticLightingMapping* FLightmassExporter::FindMappingByGuid(FGuid FindGuid) const
{
	for( int32 MappingIdx=0; MappingIdx < BSPSurfaceMappings.Num(); MappingIdx++ )
	{
		const FStaticLightingMapping* CurrentMapping = BSPSurfaceMappings[MappingIdx];
		if (CurrentMapping->GetLightingGuid() == FindGuid)
		{
			return CurrentMapping;
		}
	}

	for( int32 MappingIdx=0; MappingIdx < StaticMeshTextureMappings.Num(); MappingIdx++ )
	{
		const FStaticLightingMapping* CurrentMapping = StaticMeshTextureMappings[MappingIdx];
		if (CurrentMapping->GetLightingGuid() == FindGuid)
		{
			return CurrentMapping;
		}
	}

	for( int32 MappingIdx=0; MappingIdx < LandscapeTextureMappings.Num(); MappingIdx++ )
	{
		const FStaticLightingMapping* CurrentMapping = LandscapeTextureMappings[MappingIdx];
		if (CurrentMapping->GetLightingGuid() == FindGuid)
		{
			return CurrentMapping;
		}
	}

	for( int32 MappingIdx=0; MappingIdx < VolumeMappings.Num(); MappingIdx++ )
	{
		const FStaticLightingMapping* CurrentMapping = VolumeMappings[MappingIdx];
		if (CurrentMapping->GetLightingGuid() == FindGuid)
		{
			return CurrentMapping;
		}
	}

	for( int32 MappingIdx=0; MappingIdx < LandscapeVolumeMappings.Num(); MappingIdx++ )
	{
		const FStaticLightingMapping* CurrentMapping = LandscapeVolumeMappings[MappingIdx];
		if (CurrentMapping->GetLightingGuid() == FindGuid)
		{
			return CurrentMapping;
		}
	}

	return NULL;
}

void FLightmassExporter::WriteToChannel( FLightmassStatistics& Stats, FGuid& DebugMappingGuid )
{
	// Initialize the debug mapping Guid to something not in the scene.
	DebugMappingGuid = FGuid(0x96dc6516, 0xa616421d, 0x82f0ef5b, 0x299152b5);
	if( bSwarmConnectionIsValid )
	{
		int32 Channel = Swarm.OpenChannel( *ChannelName, LM_SCENE_CHANNEL_FLAGS );
		if( Channel >= 0 )
		{
			// Ensure the default material is present...
			AddMaterial(UMaterial::GetDefaultMaterial(MD_Surface));

			TotalProgress = 
				DirectionalLights.Num() + PointLights.Num() + SpotLights.Num() + RectLights.Num() + SkyLights.Num() + 
				StaticMeshes.Num() + StaticMeshLightingMeshes.Num() + StaticMeshTextureMappings.Num() + 
				BSPSurfaceMappings.Num() + VolumeMappings.Num() + Materials.Num() + 
				+ LandscapeLightingMeshes.Num() + LandscapeTextureMappings.Num() + LandscapeVolumeMappings.Num();

			CurrentProgress = 0;

			// Export scene header.
			Lightmass::FSceneFileHeader Scene;
			Scene.Cookie = 'SCEN';
			Scene.FormatVersion = FGuid( 0, 0, 0, 1 );
			Scene.Guid = FGuid( 0, 0, 0, 1 );

			WriteSceneSettings(Scene);
			WriteDebugInput(Scene.DebugInput, DebugMappingGuid);

			/** If true, pad the mappings (shrink the requested size and then pad) */
			Scene.bPadMappings = GLightmassDebugOptions.bPadMappings;
			Scene.bDebugPadding = GLightmassDebugOptions.bDebugPaddings;
			Scene.ExecutionTimeDivisor = GLightmassDebugOptions.ExecutionTimeDivisor;
			Scene.bColorByExecutionTime = GLightmassDebugOptions.bColorByExecutionTime;
			Scene.bUseRandomColors = GLightmassDebugOptions.bUseRandomColors;
			Scene.bColorBordersGreen = GLightmassDebugOptions.bColorBordersGreen;
			Scene.bOnlyCalcDebugTexelMappings = GLightmassDebugOptions.bOnlyCalcDebugTexelMappings;

			Scene.NumImportanceVolumes = ImportanceVolumes.Num();
			Scene.NumCharacterIndirectDetailVolumes = CharacterIndirectDetailVolumes.Num();
			Scene.NumVolumetricLightmapDensityVolumes = VolumetricLightmapDensityVolumes.Num();
			Scene.NumPortals = Portals.Num();
			Scene.NumDirectionalLights = DirectionalLights.Num();
			Scene.NumPointLights = PointLights.Num();
			Scene.NumSpotLights = SpotLights.Num();
			Scene.NumRectLights = RectLights.Num();
			Scene.NumSkyLights = SkyLights.Num();
			Scene.NumStaticMeshes = StaticMeshes.Num();
			Scene.NumStaticMeshInstances = StaticMeshLightingMeshes.Num();
			Scene.NumFluidSurfaceInstances = 0;
			Scene.NumLandscapeInstances = LandscapeLightingMeshes.Num();
			Scene.NumBSPMappings = BSPSurfaceMappings.Num();
			Scene.NumStaticMeshTextureMappings = StaticMeshTextureMappings.Num();
			Scene.NumFluidSurfaceTextureMappings = 0;
			Scene.NumLandscapeTextureMappings = LandscapeTextureMappings.Num();
			Scene.NumSpeedTreeMappings = 0;
			Scene.NumVolumeMappings = VolumeMappings.Num();
			Scene.NumLandscapeVolumeMappings = LandscapeVolumeMappings.Num();
			Scene.NumPrecomputedVisibilityBuckets = VisibilityBucketGuids.Num();
			Scene.NumVolumetricLightmapTasks = VolumetricLightmapTaskGuids.Num();
			Swarm.WriteChannel( Channel, &Scene, sizeof(Scene) );

			const int32 UserNameLength = FCString::Strlen(FPlatformProcess::UserName());
			Swarm.WriteChannel( Channel, &UserNameLength, sizeof(UserNameLength) );
			Swarm.WriteChannel( Channel, FPlatformProcess::UserName(), UserNameLength * sizeof(TCHAR) );

			const int32 LevelNameLength = LevelName.Len();
			Swarm.WriteChannel( Channel, &LevelNameLength, sizeof(LevelNameLength) );
			Swarm.WriteChannel( Channel, *LevelName, LevelName.Len() * sizeof(TCHAR) );

			for (int32 VolumeIndex = 0; VolumeIndex < ImportanceVolumes.Num(); VolumeIndex++)
			{
				FBox3f LMBox(ImportanceVolumes[VolumeIndex]);
				Swarm.WriteChannel(Channel, &LMBox, sizeof(LMBox));
			}

			for (int32 VolumeIndex = 0; VolumeIndex < CharacterIndirectDetailVolumes.Num(); VolumeIndex++)
			{
				FBox3f LMBox(CharacterIndirectDetailVolumes[VolumeIndex]);
				Swarm.WriteChannel(Channel, &LMBox, sizeof(LMBox));
			}

			for (int32 PortalIndex = 0; PortalIndex < Portals.Num(); PortalIndex++)
			{
				FMatrix44f Matrix(Portals[PortalIndex]);
				Swarm.WriteChannel(Channel, &Matrix, sizeof(Matrix));
			}

			{
				FLightmassStatistics::FScopedGather VisibilityStat(Stats.ExportVisibilityDataTime);
				WriteVisibilityData(Channel);
			}
			{
				FLightmassStatistics::FScopedGather VisibilityStat(Stats.ExportVolumetricLightmapDataTime);
				WriteVolumetricLightmapData(Channel);
			}
			{
				FLightmassStatistics::FScopedGather LightStat(Stats.ExportLightsTime);
				WriteLights( Channel );
			}
			{
				FLightmassStatistics::FScopedGather ModelStat(Stats.ExportModelsTime);
				WriteModels();
			}
			{
				FLightmassStatistics::FScopedGather StaticMeshStat(Stats.ExportStaticMeshesTime);
				WriteStaticMeshes();
			}
			{
				FLightmassStatistics::FScopedGather MeshInstanceStat(Stats.ExportMeshInstancesTime);
				WriteMeshInstances( Channel );
			}
			{
				FLightmassStatistics::FScopedGather LandscapeInstanceStat(Stats.ExportLandscapeInstancesTime);
				WriteLandscapeInstances( Channel );
			}
			{
				FLightmassStatistics::FScopedGather MappingStat(Stats.ExportMappingsTime);
				WriteMappings( Channel );
			}

			Swarm.CloseChannel( Channel );
		}
		else
		{
			UE_LOG(LogLightmassSolver, Log,  TEXT("Error, OpenChannel failed to open %s with error code %d"), *ChannelName, Channel );
		}
	}
}

bool FLightmassExporter::WriteToMaterialChannel(FLightmassStatistics& Stats)
{
	if (bSwarmConnectionIsValid && !GEditor->GetMapBuildCancelled())
	{
		if (ExportStage == NotRunning) {ExportStage = BuildMaterials;}

		double ExportTime = 0.0;

		while (ExportTime < AllowedAmortizationTimePerTick && ExportStage != Complete)
		{
			FLightmassStatistics::FScopedGather ExportStat(ExportTime);
			switch (ExportStage)
			{
			case BuildMaterials:
				{
					if (CurrentAmortizationIndex >= Materials.Num()) 
					{
						ExportStage = ShaderCompilation; 
						CurrentAmortizationIndex = 0;
					}
					else
					{
						BuildMaterialMap(Materials[CurrentAmortizationIndex]);
						++CurrentAmortizationIndex;
					}
				}
				break;
			case ShaderCompilation:
				{
					BlockOnShaderCompilation();
					ExportStage = ExportMaterials;
					CurrentAmortizationIndex = 0;
				}
				break;
			case ExportMaterials:
				{
					if (CurrentAmortizationIndex >= Materials.Num()) 
					{
						ExportStage = CleanupMaterialExport; 
						CurrentAmortizationIndex = 0;
					}
					else
					{
						auto* CurrentMaterial = Materials[CurrentAmortizationIndex];
						ExportMaterial(CurrentMaterial, MaterialExportSettings.FindChecked(CurrentMaterial));
						++CurrentAmortizationIndex;
					}
				}
				break;
			case CleanupMaterialExport:
				{
					if (CurrentAmortizationIndex >= OpenedMaterialExportChannels.Num()) 
					{
						ExportStage = Complete; 
						CurrentAmortizationIndex = 0;
					}
					else
					{
						Swarm.CloseChannel(OpenedMaterialExportChannels[CurrentAmortizationIndex]);
						++CurrentAmortizationIndex;
					}
				}
				break;
			default: UE_LOG(LogLightmassSolver, Fatal, TEXT("Invalid amortization stage hit."));
			}
		}

		Stats.ExportMaterialsTime += ExportTime;

		return ExportStage == Complete;
	}
	else
	{
		return true;
	}
}

float FLightmassExporter::GetAmortizedExportPercentDone() const
{
	int32 EstimatedTotalTaskCount = Materials.Num() * 3;
	int32 CurrentTaskId = ExportStage == BuildMaterials ? CurrentAmortizationIndex:
		ExportStage == ShaderCompilation ? Materials.Num():
		ExportStage == ExportMaterials ? (Materials.Num() + CurrentAmortizationIndex) :
		ExportStage == CleanupMaterialExport ? (Materials.Num() * 2 + CurrentAmortizationIndex) : EstimatedTotalTaskCount;
	return static_cast<float>(CurrentTaskId) / EstimatedTotalTaskCount;
}

void FLightmassExporter::WriteVisibilityData( int32 Channel )
{
	Swarm.WriteChannel( Channel, VisibilityBucketGuids.GetData(), VisibilityBucketGuids.Num() * VisibilityBucketGuids.GetTypeSize() );

	int32 NumVisVolumes = 0;
	for( TObjectIterator<APrecomputedVisibilityVolume> It; It; ++It )
	{
		if (World->ContainsActor(*It) && IsValid(*It))
		{
			NumVisVolumes++;
		}
	}

	if (World->GetWorldSettings()->bPrecomputeVisibility 
		&& NumVisVolumes == 0
		&& World->GetWorldSettings()->bPlaceCellsOnlyAlongCameraTracks == false)
	{
		FMessageLog("LightingResults").Error(LOCTEXT("LightmassError_MissingPrecomputedVisibilityVolume", "Level has bPrecomputeVisibility enabled but no Precomputed Visibility Volumes, precomputed visibility will not be effective."));
	}

	// Export the visibility volumes that indicate to lightmass where to place visibility cells
	Swarm.WriteChannel( Channel, &NumVisVolumes, sizeof(NumVisVolumes) );
	for( TObjectIterator<APrecomputedVisibilityVolume> It; It; ++It )
	{
		APrecomputedVisibilityVolume* Volume = *It;
		if (World->ContainsActor(Volume) && IsValid(Volume))
		{
			FBox3f LMBox(Volume->GetComponentsBoundingBox(true));
			Swarm.WriteChannel(Channel, &LMBox, sizeof(LMBox));

			TArray<FPlane> Planes4d;
			Volume->Brush->GetSurfacePlanes(Volume, Planes4d);			
			TArray<FPlane4f> Planes;
			for (FPlane Plane4d : Planes4d)
			{
				Planes.Add(FPlane4f(Plane4d));
			}
			const int32 NumPlanes = Planes.Num();
			Swarm.WriteChannel( Channel, &NumPlanes, sizeof(NumPlanes) );
			Swarm.WriteChannel( Channel, Planes.GetData(), Planes.Num() * Planes.GetTypeSize() );
		}
	}

	int32 NumOverrideVisVolumes = 0;
	for( TObjectIterator<APrecomputedVisibilityOverrideVolume> It; It; ++It )
	{
		if (World->ContainsActor(*It) && IsValid(*It))
		{
			NumOverrideVisVolumes++;
		}
	}

	Swarm.WriteChannel( Channel, &NumOverrideVisVolumes, sizeof(NumOverrideVisVolumes) );
	for( TObjectIterator<APrecomputedVisibilityOverrideVolume> It; It; ++It )
	{
		APrecomputedVisibilityOverrideVolume* Volume = *It;
		if (World->ContainsActor(Volume) && IsValid(Volume))
		{
			FBox3f LMBox(Volume->GetComponentsBoundingBox(true));
			Swarm.WriteChannel(Channel, &LMBox, sizeof(LMBox));

			TArray<int32> VisibilityIds;
			for (int32 ActorIndex = 0; ActorIndex < Volume->OverrideVisibleActors.Num(); ActorIndex++)
			{
				AActor* CurrentActor = Volume->OverrideVisibleActors[ActorIndex];
				if (CurrentActor)
				{
					for (UActorComponent* Component : CurrentActor->GetComponents())
					{
						UPrimitiveComponent* CurrentComponent = Cast<UPrimitiveComponent>(Component);
						if (CurrentComponent && (CurrentComponent->Mobility == EComponentMobility::Static) && CurrentComponent->VisibilityId != INDEX_NONE)
						{
							VisibilityIds.AddUnique(CurrentComponent->VisibilityId);
						}
					}
				}
			}
			TArray<int32> InvisibilityIds;
			for (int32 RemoveActorIndex = 0; RemoveActorIndex < Volume->OverrideInvisibleActors.Num(); RemoveActorIndex++)
			{
				AActor* RemoveActor = Volume->OverrideInvisibleActors[RemoveActorIndex];
				if (RemoveActor)
				{
					for (UActorComponent* Component : RemoveActor->GetComponents())
					{
						UPrimitiveComponent* RemoveComponent = Cast<UPrimitiveComponent>(Component);
						if (RemoveComponent && (RemoveComponent->Mobility == EComponentMobility::Static) && RemoveComponent->VisibilityId != INDEX_NONE)
						{
							InvisibilityIds.AddUnique(RemoveComponent->VisibilityId);
						}
					}
				}
			}
			for (int32 RemoveLevelIndex = 0; RemoveLevelIndex < Volume->OverrideInvisibleLevels.Num(); RemoveLevelIndex++)
			{
				ULevelStreaming* LevelStreaming = World->GetLevelStreamingForPackageName(Volume->OverrideInvisibleLevels[RemoveLevelIndex]);
				ULevel* Level;
				if( LevelStreaming && (Level = LevelStreaming->GetLoadedLevel()) != NULL )
				{
					for (int32 RemoveActorIndex = 0; RemoveActorIndex < Level->Actors.Num(); RemoveActorIndex++)
					{
						AActor* RemoveActor = Level->Actors[RemoveActorIndex];
						if (RemoveActor)
						{
							for (UActorComponent* Component : RemoveActor->GetComponents())
							{
								UPrimitiveComponent* RemoveComponent = Cast<UPrimitiveComponent>(Component);
								if (RemoveComponent && (RemoveComponent->Mobility == EComponentMobility::Static) && RemoveComponent->VisibilityId != INDEX_NONE)
								{
									InvisibilityIds.AddUnique(RemoveComponent->VisibilityId);
								}
							}
						}
					}
				}
			}
			
			const int32 NumVisibilityIds = VisibilityIds.Num();
			Swarm.WriteChannel( Channel, &NumVisibilityIds, sizeof(NumVisibilityIds) );
			Swarm.WriteChannel( Channel, VisibilityIds.GetData(), VisibilityIds.Num() * VisibilityIds.GetTypeSize() );
			const int32 NumInvisibilityIds = InvisibilityIds.Num();
			Swarm.WriteChannel( Channel, &NumInvisibilityIds, sizeof(NumInvisibilityIds) );
			Swarm.WriteChannel( Channel, InvisibilityIds.GetData(), InvisibilityIds.Num() * InvisibilityIds.GetTypeSize() );
		}
	}

	const float CellSize = World->GetWorldSettings()->VisibilityCellSize;

	// This used to walk along Matinee sequences and write the positions for pre-computed visibility.
	// Leaving the swarm channel code here for fear of breaking swarm.
	TArray<FVector4f> CameraTrackPositions;
	int32 NumCameraPositions = CameraTrackPositions.Num();
	Swarm.WriteChannel( Channel, &NumCameraPositions, sizeof(NumCameraPositions) );
	Swarm.WriteChannel( Channel, CameraTrackPositions.GetData(), CameraTrackPositions.Num() * CameraTrackPositions.GetTypeSize() );
}

void FLightmassExporter::WriteVolumetricLightmapData( int32 Channel )
{
	for (int32 VolumeIndex = 0; VolumeIndex < VolumetricLightmapDensityVolumes.Num(); VolumeIndex++)
	{
		AVolumetricLightmapDensityVolume* DetailVolume = VolumetricLightmapDensityVolumes[VolumeIndex];

		Lightmass::FVolumetricLightmapDensityVolumeData VolumeData;
		VolumeData.Bounds = FBox3f(DetailVolume->GetComponentsBoundingBox(true));
		VolumeData.AllowedMipLevelRange = FIntPoint(DetailVolume->AllowedMipLevelRange.Min, DetailVolume->AllowedMipLevelRange.Max);

		TArray<FPlane> Planes4d;
		DetailVolume->Brush->GetSurfacePlanes(DetailVolume, Planes4d);
		TArray<FPlane4f> Planes;
		for (FPlane Plane4d : Planes4d)
		{
			Planes.Add(FPlane4f(Plane4d));
		}

		VolumeData.NumPlanes = Planes.Num();

		Swarm.WriteChannel( Channel, &VolumeData, sizeof(VolumeData) );
		Swarm.WriteChannel( Channel, Planes.GetData(), Planes.Num() * Planes.GetTypeSize() );
	}

	TArray<FGuid> VolumetricLightmapTaskGuidsArray;
	VolumetricLightmapTaskGuids.GenerateKeyArray(VolumetricLightmapTaskGuidsArray);
	Swarm.WriteChannel( Channel, VolumetricLightmapTaskGuidsArray.GetData(), VolumetricLightmapTaskGuidsArray.Num() * VolumetricLightmapTaskGuidsArray.GetTypeSize() );
}

void FLightmassExporter::WriteLights( int32 Channel )
{
	// Search for the sun light component the same way as in FScene::RemoveLightSceneInfo_RenderThread.
	// If found, we keep the pointer to apply atmosphere transmittance to it in the light loop.
	const UDirectionalLightComponent* AtmosphereLights[NUM_ATMOSPHERE_LIGHTS];
	float AtmosphereLightsBrightness[NUM_ATMOSPHERE_LIGHTS];
	FLinearColor SunLightAtmosphereTransmittance[NUM_ATMOSPHERE_LIGHTS];
	for (uint8 Index = 0; Index < NUM_ATMOSPHERE_LIGHTS; ++Index)
	{
		AtmosphereLights[Index] = nullptr;
		AtmosphereLightsBrightness[Index] = 0.0f;
		SunLightAtmosphereTransmittance[Index] = FLinearColor::White;
	}

	PRAGMA_DISABLE_DEPRECATION_WARNINGS
	// Compute a mapping between directional light and trnasmittance to apply. For each AtmosphereSunLightIndex, the brightest lights is kept.
	if (SkyAtmosphereComponent)
	{
		for (int32 LightIndex = 0; LightIndex < DirectionalLights.Num(); ++LightIndex)
		{
			const UDirectionalLightComponent* Light = DirectionalLights[LightIndex];
			if (Light->IsUsedAsAtmosphereSunLight() && Light->GetColoredLightBrightness().GetLuminance() > AtmosphereLightsBrightness[Light->GetAtmosphereSunLightIndex()])
			{
				AtmosphereLights[Light->GetAtmosphereSunLightIndex()] = Light;
				AtmosphereLightsBrightness[Light->GetAtmosphereSunLightIndex()] = Light->GetColoredLightBrightness().GetLuminance();
			}
		}

		for (uint8 Index = 0; Index < NUM_ATMOSPHERE_LIGHTS; ++Index)
		{
			if (AtmosphereLights[Index])
			{
				const FVector SunDirection = -AtmosphereLights[Index]->GetDirection();
				if (SkyAtmosphereComponent)
				{
					FAtmosphereSetup AtmosphereSetup(*SkyAtmosphereComponent);
					SunLightAtmosphereTransmittance[Index] = AtmosphereSetup.GetTransmittanceAtGroundLevel(SunDirection);
				}
				break;
			}
		}
	}
	PRAGMA_ENABLE_DEPRECATION_WARNINGS

	// Export directional lights.
	for ( int32 LightIndex = 0; LightIndex < DirectionalLights.Num(); ++LightIndex )
	{
		const UDirectionalLightComponent* Light = DirectionalLights[LightIndex];
		Lightmass::FLightData LightData;
		Lightmass::FDirectionalLightData DirectionalData;
		Copy( Light, LightData );
		LightData.IndirectLightingSaturation = Light->LightmassSettings.IndirectLightingSaturation;
		LightData.ShadowExponent = Light->LightmassSettings.ShadowExponent;
		LightData.ShadowResolutionScale = Light->ShadowResolutionScale;
		LightData.LightSourceRadius = 0;
		LightData.LightSourceLength = 0;

		// Apply atmosphere transmittance if needed.
		for (uint8 Index = 0; Index < NUM_ATMOSPHERE_LIGHTS; ++Index)
		{
			if (AtmosphereLights[Index] && AtmosphereLights[Index] == Light)
			{
				LightData.Color *= SunLightAtmosphereTransmittance[Index];
				break;
			}
		}

		TArray< uint8 > LightProfileTextureData;
		CopyLightProfile( Light, LightData, LightProfileTextureData );

		DirectionalData.LightSourceAngle = Light->LightmassSettings.LightSourceAngle * (float)PI / 180.0f;
		Swarm.WriteChannel( Channel, &LightData, sizeof(LightData) );
		Swarm.WriteChannel( Channel, LightProfileTextureData.GetData(), LightProfileTextureData.Num() * LightProfileTextureData.GetTypeSize() );
		Swarm.WriteChannel( Channel, &DirectionalData, sizeof(DirectionalData) );
		UpdateExportProgress();
	}

	// Export point lights.
	for ( int32 LightIndex = 0; LightIndex < PointLights.Num(); ++LightIndex )
	{
		const UPointLightComponent* Light = PointLights[LightIndex];
		Lightmass::FLightData LightData;
		Lightmass::FPointLightData PointData;
		Copy( Light, LightData );
		LightData.IndirectLightingSaturation = Light->LightmassSettings.IndirectLightingSaturation;
		LightData.ShadowExponent = Light->LightmassSettings.ShadowExponent;
		LightData.ShadowResolutionScale = Light->ShadowResolutionScale;
		LightData.LightSourceRadius = FMath::Max( 1.0f, Light->SourceRadius );
		LightData.LightSourceLength = Light->SourceLength;

		TArray< uint8 > LightProfileTextureData;
		CopyLightProfile( Light, LightData, LightProfileTextureData );

		PointData.Radius = Light->AttenuationRadius;
		PointData.FalloffExponent = Light->LightFalloffExponent;
		PointData.LightTangent = FVector3f(Light->GetComponentTransform().GetUnitAxis(EAxis::Z));
		Swarm.WriteChannel( Channel, &LightData, sizeof(LightData) );
		Swarm.WriteChannel( Channel, LightProfileTextureData.GetData(), LightProfileTextureData.Num() * LightProfileTextureData.GetTypeSize() );
		Swarm.WriteChannel( Channel, &PointData, sizeof(PointData) );
		UpdateExportProgress();
	}

	// Export spot lights.
	for ( int32 LightIndex = 0; LightIndex < SpotLights.Num(); ++LightIndex )
	{
		const USpotLightComponent* Light = SpotLights[LightIndex];
		Lightmass::FLightData LightData;
		Lightmass::FPointLightData PointData;
		Lightmass::FSpotLightData SpotData;
		Copy( Light, LightData ); 
		LightData.IndirectLightingSaturation = Light->LightmassSettings.IndirectLightingSaturation;
		LightData.ShadowExponent = Light->LightmassSettings.ShadowExponent;
		LightData.ShadowResolutionScale = Light->ShadowResolutionScale;
		LightData.LightSourceRadius = FMath::Max( 1.0f, Light->SourceRadius );
		LightData.LightSourceLength = Light->SourceLength;

		TArray< uint8 > LightProfileTextureData;
		CopyLightProfile( Light, LightData, LightProfileTextureData );

		PointData.Radius = Light->AttenuationRadius;
		PointData.FalloffExponent = Light->LightFalloffExponent;
		PointData.LightTangent = FVector3f(Light->GetComponentTransform().GetUnitAxis(EAxis::Z));
		SpotData.InnerConeAngle = Light->InnerConeAngle; 
		SpotData.OuterConeAngle = Light->OuterConeAngle;
		Swarm.WriteChannel( Channel, &LightData, sizeof(LightData) );
		Swarm.WriteChannel( Channel, LightProfileTextureData.GetData(), LightProfileTextureData.Num() * LightProfileTextureData.GetTypeSize() );
		Swarm.WriteChannel( Channel, &PointData, sizeof(PointData) );
		Swarm.WriteChannel( Channel, &SpotData, sizeof(SpotData) );
		UpdateExportProgress();
	}

	// Export rect lights.
	for ( int32 LightIndex = 0; LightIndex < RectLights.Num(); ++LightIndex )
	{
		const URectLightComponent* Light = RectLights[LightIndex];
		Lightmass::FLightData LightData;
		Copy( Light, LightData );
		LightData.IndirectLightingSaturation = Light->LightmassSettings.IndirectLightingSaturation;
		LightData.ShadowExponent = Light->LightmassSettings.ShadowExponent;
		LightData.ShadowResolutionScale = Light->ShadowResolutionScale;
		LightData.LightSourceRadius = 0.5f * Light->SourceWidth;
		LightData.LightSourceLength = 0.5f * Light->SourceHeight;

		TArray< uint8 > LightProfileTextureData;
		CopyLightProfile( Light, LightData, LightProfileTextureData );

		Lightmass::FPointLightData PointData;
		PointData.Radius = Light->AttenuationRadius;
		PointData.FalloffExponent = 0.0f;
		PointData.LightTangent = FVector3f(Light->GetComponentTransform().GetUnitAxis(EAxis::Z));

		Lightmass::FRectLightData RectData = { 0, 0, FLinearColor::White };
		// TODO export texture data. Below code is written for that in mind but source data doesn't contain mips.
		//TArray< FFloat16Color > SourceTexture;
		if( Light->SourceTexture )
		{
			FTextureSource& Source = Light->SourceTexture->Source;

			if( Source.IsValid() )
			{
				ETextureSourceFormat Format = Source.GetFormat();
				int32 BytesPerPixel = Source.GetBytesPerPixel();
				bool SRGB = Light->SourceTexture->SRGB;

				uint32 NumMips = Source.GetNumMips();
				uint32 MipLevel = NumMips - FMath::Min( NumMips, 8u );

				uint32 SizeX = FMath::Max( Source.GetSizeX() >> MipLevel, 1 );
				uint32 SizeY = FMath::Max( Source.GetSizeY() >> MipLevel, 1 );

				RectData.SourceTextureSizeX = SizeX;
				RectData.SourceTextureSizeY = SizeY;

				ERawImageFormat::Type RawFormat = FImageCoreUtils::ConvertToRawImageFormat(Format);

				if ( SizeX > 1 || SizeY > 1 )
				{
					TArray64< uint8 > MipData;
					verify( Source.GetMipData( MipData, MipLevel ) );

					uint8* Pixel = MipData.GetData();
					uint8* PixelEnd = Pixel + MipData.Num();
					while( Pixel < PixelEnd )
					{
						FLinearColor Color = ERawImageFormat::GetOnePixelLinear(Pixel,RawFormat,SRGB);
						RectData.SourceTextureAvgColor += Color;

						Pixel += BytesPerPixel;
					}

					RectData.SourceTextureAvgColor *= 1.0f / ( SizeX * SizeY );
				}
			}
		}

		Swarm.WriteChannel( Channel, &LightData, sizeof(LightData) );
		Swarm.WriteChannel( Channel, LightProfileTextureData.GetData(), LightProfileTextureData.Num() * LightProfileTextureData.GetTypeSize() );
		Swarm.WriteChannel( Channel, &PointData, sizeof(PointData) );
		Swarm.WriteChannel( Channel, &RectData, sizeof(RectData) );
		//Swarm.WriteChannel( Channel, SourceTexture.GetData(), SourceTexture.Num() * SourceTexture.GetTypeSize() );
		UpdateExportProgress();
	}

	// Export sky lights.
	for ( int32 LightIndex = 0; LightIndex < SkyLights.Num(); ++LightIndex )
	{
		const USkyLightComponent* Light = SkyLights[LightIndex];

		Lightmass::FLightData LightData;
		Lightmass::FSkyLightData SkyData;
		Copy( Light, LightData ); 

		TArray< uint8 > LightProfileTextureData;
		CopyLightProfile( Light, LightData, LightProfileTextureData );

		TArray<FFloat16Color> RadianceMap;

		// Capture the scene's emissive and send it to lightmass
		// Note: FLightmassProcessor::InitiateExport hid all but the current lighting scenario
		Light->CaptureEmissiveRadianceEnvironmentCubeMap(SkyData.IrradianceEnvironmentMap, RadianceMap);

		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bUseFilteredCubemapForSkylight"), SkyData.bUseFilteredCubemap, GLightmassIni));
		SkyData.RadianceEnvironmentMapDataSize = RadianceMap.Num();
		Swarm.WriteChannel( Channel, &LightData, sizeof(LightData) );
		Swarm.WriteChannel( Channel, LightProfileTextureData.GetData(), LightProfileTextureData.Num() * LightProfileTextureData.GetTypeSize() );
		Swarm.WriteChannel( Channel, &SkyData, sizeof(SkyData) );
		Swarm.WriteChannel( Channel, RadianceMap.GetData(), RadianceMap.Num() * RadianceMap.GetTypeSize() );
		UpdateExportProgress();
	}
}

/**
 * Exports all UModels to secondary, persistent channels
 */
void FLightmassExporter::WriteModels()
{
	for (int32 ModelIndex = 0; ModelIndex < Models.Num(); ModelIndex++)
	{
		
	}
}

/**
 * Exports all UStaticMeshes to secondary, persistent channels
 */
void FLightmassExporter::WriteStaticMeshes()
{
	// Export geometry resources.
	for (int32 StaticMeshIndex = 0; StaticMeshIndex < StaticMeshes.Num() && !GEditor->GetMapBuildCancelled(); StaticMeshIndex++)
	{
		const UStaticMesh* StaticMesh = StaticMeshes[StaticMeshIndex];

		Lightmass::FBaseMeshData BaseMeshData;
		BaseMeshData.Guid = StaticMesh->GetLightingGuid();

		// create a channel name to write the mesh out to
		FString NewChannelName = Lightmass::CreateChannelNameWithLMExecutableHash(BaseMeshData.Guid, Lightmass::LM_STATICMESH_VERSION, LightmassExecutableHash, Lightmass::LM_STATICMESH_EXTENSION);

		// Warn the user if there is an invalid lightmap UV channel specified.
		if( StaticMesh->GetLightMapCoordinateIndex() > 0
			&& StaticMesh->GetRenderData()
			&& StaticMesh->GetRenderData()->LODResources.Num() > 0 )
		{
			const FStaticMeshLODResources& RenderData = StaticMesh->GetRenderData()->LODResources[0];
			if( StaticMesh->GetLightMapCoordinateIndex() >= (int32)RenderData.VertexBuffers.StaticMeshVertexBuffer.GetNumTexCoords() )
			{
				FMessageLog("LightingResults").Warning()
					->AddToken(FUObjectToken::Create(const_cast<UStaticMesh*>(StaticMesh)))
					->AddToken(FTextToken::Create( NSLOCTEXT("Lightmass", "LightmassError_BadLightMapCoordinateIndex", "StaticMesh has invalid LightMapCoordinateIndex.") ) );
			}
		}

		// only export the static mesh if it's not currently in the cache
		if ((GSwarmDebugOptions.bForceContentExport == true) ||
			(Swarm.TestChannel(*NewChannelName) < 0))
		{
			// open the channel
			int32 Channel = Swarm.OpenChannel( *NewChannelName, LM_STATICMESH_CHANNEL_FLAGS );
			if( Channel >= 0 )
			{
				// write out base data
				Swarm.WriteChannel(Channel, &BaseMeshData, sizeof(BaseMeshData));

				Lightmass::FStaticMeshData StaticMeshData;
				StaticMeshData.LightmapCoordinateIndex = StaticMesh->GetLightMapCoordinateIndex();
				StaticMeshData.NumLODs = StaticMesh->GetRenderData()->LODResources.Num();
				Swarm.WriteChannel( Channel, &StaticMeshData, sizeof(StaticMeshData) );
				for (int32 LODIndex = 0; LODIndex < StaticMesh->GetRenderData()->LODResources.Num(); LODIndex++)
				{
					TArray<uint32> Indices;
					const FStaticMeshLODResources& RenderData = StaticMesh->GetRenderData()->LODResources[LODIndex];

					RenderData.IndexBuffer.GetCopy(Indices);
					Lightmass::FStaticMeshLODData SMLODData;
					SMLODData.NumElements = RenderData.Sections.Num();
					SMLODData.NumTriangles = RenderData.GetNumTriangles();
					SMLODData.NumIndices = Indices.Num();
					// the vertex buffer could have double vertices for shadow buffer data, so we use what the render data thinks it has, not what is actually there
					SMLODData.NumVertices = RenderData.VertexBuffers.StaticMeshVertexBuffer.GetNumVertices();
					Swarm.WriteChannel( Channel, &SMLODData, sizeof(SMLODData) );

					int32 NumSections = RenderData.Sections.Num();
					if( NumSections > 0 )
					{
						TArray<Lightmass::FStaticMeshElementData> LMElements;
						LMElements.Empty(NumSections);
						LMElements.AddZeroed(NumSections);
						for (int32 SectionIndex = 0; SectionIndex < NumSections; SectionIndex++)
						{
							const FStaticMeshSection& Section = RenderData.Sections[SectionIndex];
							Lightmass::FStaticMeshElementData& SMElementData = LMElements[SectionIndex];
							SMElementData.FirstIndex = Section.FirstIndex;
							SMElementData.NumTriangles = Section.NumTriangles;
							SMElementData.bEnableShadowCasting = Section.bCastShadow;
						}
						Swarm.WriteChannel( Channel, (void*)(LMElements.GetData()), NumSections * sizeof(Lightmass::FStaticMeshElementData) );
					}

					Swarm.WriteChannel( Channel, (void*)Indices.GetData(), Indices.Num() * sizeof(uint32) );
					
					int32 VertexCount = SMLODData.NumVertices;
					if( VertexCount > 0 )
					{
						TArray<Lightmass::FStaticMeshVertex> LMVertices;
						LMVertices.Empty(VertexCount);
						LMVertices.AddZeroed(VertexCount);
						for (int32 VertexIndex = 0; VertexIndex < VertexCount; VertexIndex++)
						{
							Lightmass::FStaticMeshVertex& Vertex = LMVertices[VertexIndex];
							Vertex.Position = FVector4f(RenderData.VertexBuffers.PositionVertexBuffer.VertexPosition(VertexIndex), 1.0f);
							Vertex.TangentX = FVector4f(RenderData.VertexBuffers.StaticMeshVertexBuffer.VertexTangentX(VertexIndex));
							Vertex.TangentY = FVector4f(RenderData.VertexBuffers.StaticMeshVertexBuffer.VertexTangentY(VertexIndex));
							Vertex.TangentZ = FVector4f(RenderData.VertexBuffers.StaticMeshVertexBuffer.VertexTangentZ(VertexIndex));
							int32 UVCount = FMath::Clamp<int32>(RenderData.VertexBuffers.StaticMeshVertexBuffer.GetNumTexCoords(), 0, MAX_TEXCOORDS);
							int32 UVIndex;
							for (UVIndex = 0; UVIndex < UVCount; UVIndex++)
							{
								Vertex.UVs[UVIndex] = RenderData.VertexBuffers.StaticMeshVertexBuffer.GetVertexUV(VertexIndex, UVIndex);
							}

							for (; UVIndex < MAX_TEXCOORDS; UVIndex++)
							{
								Vertex.UVs[UVIndex] = FVector2f::ZeroVector;
							}
						}
						Swarm.WriteChannel( Channel, (void*)(LMVertices.GetData()), LMVertices.Num() * sizeof(Lightmass::FStaticMeshVertex));
					}
				}

				// close the channel, the whole mesh is now exported
				Swarm.CloseChannel(Channel);
			}
			else
			{
				UE_LOG(LogLightmassSolver, Log,  TEXT("Error, OpenChannel failed to open %s with error code %d"), *NewChannelName, Channel );
			}
		}
		UpdateExportProgress();
	}
}

void FLightmassExporter::GetMaterialHash(const UMaterialInterface* Material, FSHAHash& OutHash)
{
	FSHA1 HashState;

	TArray<FGuid> MaterialGuids;
	Material->GetLightingGuidChain(true, MaterialGuids);
	MaterialGuids.Sort();

	FGuid LastGuid;
	for (const FGuid& MaterialGuid : MaterialGuids)
	{
		if (MaterialGuid != LastGuid)
		{
			HashState.Update((const uint8*)&MaterialGuid, sizeof(MaterialGuid));
			LastGuid = MaterialGuid;
		}
	}

	if (Substrate::IsSubstrateEnabled())
	{
		uint32 LightmassSubstrateVersion = 0XFA1081D0; // This can be change when the code/logic for converting material to Substrate for lightmap has changed.
		HashState.Update((const uint8*)&LightmassSubstrateVersion, sizeof(LightmassSubstrateVersion));
	}

	HashState.Final();
	HashState.GetHash(&OutHash.Hash[0]);
}

void FLightmassExporter::BuildMaterialMap(UMaterialInterface* Material)
{
	if (ensure(Material))
	{
		FSHAHash MaterialHash;
		GetMaterialHash(Material, MaterialHash);

		// create a channel name to write the material out to
		FString NewChannelName = Lightmass::CreateChannelNameWithLMExecutableHash(MaterialHash, Lightmass::LM_MATERIAL_VERSION, LightmassExecutableHash, Lightmass::LM_MATERIAL_EXTENSION);

		// only export the material if it's not currently in the cache
		int32 ErrorCode;
		if ( GSwarmDebugOptions.bForceContentExport == true )
		{
			// If we're forcing export of content, pretend we didn't find it
			ErrorCode = NSwarm::SWARM_ERROR_FILE_FOUND_NOT;
		}
		else
		{
			// Otherwise, test the channel
			ErrorCode = Swarm.TestChannel(*NewChannelName);
		}

		if ( ErrorCode != NSwarm::SWARM_SUCCESS )
		{
			if( ErrorCode == NSwarm::SWARM_ERROR_FILE_FOUND_NOT )
			{
				static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.NormalMapsForStaticLighting"));
				const bool bUseNormalMapsForLighting = CVar->GetValueOnGameThread() != 0;

				// Only generate normal maps if we'll actually need them for lighting
				MaterialRenderer.BeginGenerateMaterialData(Material, bUseNormalMapsForLighting, NewChannelName, MaterialExportData);
			}
			else
			{
				UE_LOG(LogLightmassSolver, Warning, TEXT("Error in TestChannel() for %s: %s"), *(MaterialHash.ToString()), *(Material->GetPathName()));
			}
		}
	}
}

void FLightmassExporter::BlockOnShaderCompilation()
{
	// Block until async shader compiling is finished before we try to use the shaders for exporting
	// The code is structured to only block once for all materials, so that shader compiling is able to utilize many cores
	GShaderCompilingManager->FinishAllCompilation();
}

void FLightmassExporter::ExportMaterial(UMaterialInterface* Material, const FLightmassMaterialExportSettings& ExportSettings)
{
	FMaterialExportDataEntry* ExportEntry = MaterialExportData.Find(Material);

	// Only create the Swarm channel if there is something to export
	if (ensure(Material) && ExportEntry)
	{
		Lightmass::FBaseMaterialData BaseMaterialData;
		BaseMaterialData.Guid = Material->GetLightingGuid();

		// Generate the required information
		Lightmass::FMaterialData MaterialData;
		FMemory::Memzero(&MaterialData,sizeof(MaterialData));
		UMaterial* BaseMaterial = Material->GetMaterial();
		MaterialData.bTwoSided = (uint32)Material->IsTwoSided();
		MaterialData.bIsThinSurface = (uint32)Material->IsThinSurface();
		MaterialData.EmissiveBoost = Material->GetEmissiveBoost();
		MaterialData.DiffuseBoost = Material->GetDiffuseBoost();

		TArray<FFloat16Color> MaterialEmissive;
		TArray<FFloat16Color> MaterialDiffuse;
		TArray<FFloat16Color> MaterialTransmission;
		TArray<FFloat16Color> MaterialNormal;

		if (MaterialRenderer.GenerateMaterialData(
			World->Scene,
			*Material,
			ExportSettings,
			MaterialData,
			*ExportEntry,
			MaterialDiffuse,
			MaterialEmissive,
			MaterialTransmission,
			MaterialNormal))
		{
			// open the channel
			int32 Channel = Swarm.OpenChannel( *(ExportEntry->ChannelName), LM_MATERIAL_CHANNEL_FLAGS );
			if( Channel >= 0 )
			{
				// write out base data
				Swarm.WriteChannel(Channel, &BaseMaterialData, sizeof(BaseMaterialData));

				// the material data
				Swarm.WriteChannel(Channel, &MaterialData, sizeof(MaterialData));

				// Write each array of data
				uint8* OutData;
				int32 OutSize;

				OutSize = FMath::Square(MaterialData.EmissiveSize) * sizeof(FFloat16Color);
				if (OutSize > 0)
				{
					OutData = (uint8*)(MaterialEmissive.GetData());
					Swarm.WriteChannel(Channel, OutData, OutSize);
				}

				OutSize = FMath::Square(MaterialData.DiffuseSize) * sizeof(FFloat16Color);
				if (OutSize > 0)
				{
					OutData = (uint8*)(MaterialDiffuse.GetData());
					Swarm.WriteChannel(Channel, OutData, OutSize);
				}
		
				OutSize = FMath::Square(MaterialData.TransmissionSize) * sizeof(FFloat16Color);
				if (OutSize > 0)
				{
					OutData = (uint8*)(MaterialTransmission.GetData());
					Swarm.WriteChannel(Channel, OutData, OutSize);
				}

				OutSize = FMath::Square(MaterialData.NormalSize) * sizeof(FFloat16Color);
				if (OutSize > 0)
				{
					OutData = (uint8*)(MaterialNormal.GetData());
					Swarm.WriteChannel(Channel, OutData, OutSize);
				}

				OpenedMaterialExportChannels.Add(Channel);
			}
			else
			{
				UE_LOG(LogLightmassSolver, Warning, TEXT("Failed to open channel for material data for %s: %s"), *(Material->GetLightingGuid().ToString()), *(Material->GetPathName()));
			}
		}
		else
		{
			UE_LOG(LogLightmassSolver, Warning, TEXT("Failed to generate material data for %s: %s"), *(Material->GetLightingGuid().ToString()), *(Material->GetPathName()));
		}
	}
		
	UpdateExportProgress();
}

void FLightmassExporter::WriteBaseMeshInstanceData( int32 Channel, int32 MeshIndex, const FStaticLightingMesh* Mesh, TArray<Lightmass::FMaterialElementData>& MaterialElementData )
{
	Lightmass::FStaticLightingMeshInstanceData MeshInstanceData;
	FMemory::Memzero(&MeshInstanceData,sizeof(MeshInstanceData));
	MeshInstanceData.Guid = Mesh->Guid;
	MeshInstanceData.NumTriangles = Mesh->NumTriangles;
	MeshInstanceData.NumShadingTriangles = Mesh->NumShadingTriangles;
	MeshInstanceData.NumVertices = Mesh->NumVertices;
	MeshInstanceData.NumShadingVertices = Mesh->NumShadingVertices;
	MeshInstanceData.MeshIndex = MeshIndex;
	MeshInstanceData.LevelGuid = LightingContext.GetPersistentLevelGuid();
	check(Mesh->Component);
	bool bFoundLevel = false;
	AActor* ComponentOwner = Mesh->Component->GetOwner();
	if (ComponentOwner && ComponentOwner->GetLevel())
	{
		MeshInstanceData.LevelGuid = LightingContext.GetLevelGuidForActor(ComponentOwner);
		bFoundLevel = true;
	}
	else if (Mesh->Component->IsA(UModelComponent::StaticClass()))
	{
		const UModelComponent* ModelComponent = CastChecked<UModelComponent>(Mesh->Component);
		for (int32 LevelIndex = 0; LevelIndex < World->GetNumLevels(); LevelIndex++)
		{
			if (ModelComponent->GetModel() == World->GetLevel(LevelIndex)->Model)
			{
				MeshInstanceData.LevelGuid = LightingContext.GetLevelGuidForLevel(World->GetLevel(LevelIndex));
				bFoundLevel = true;
				break;
			}
		}
	}
	
	if (!bFoundLevel)
	{
		UE_LOG(LogLightmassSolver, Warning, TEXT("Couldn't determine level for component %s during Lightmass export, it will be considered in the persistent level!"), *Mesh->Component->GetPathName());
	}

	MeshInstanceData.LightingFlags = 0;
	MeshInstanceData.LightingFlags |= Mesh->bCastShadow ? Lightmass::GI_INSTANCE_CASTSHADOW : 0;
	MeshInstanceData.LightingFlags |= Mesh->bTwoSidedMaterial ? Lightmass::GI_INSTANCE_TWOSIDED : 0;
	MeshInstanceData.bCastShadowAsTwoSided = Mesh->Component->bCastShadowAsTwoSided;
	MeshInstanceData.bMovable = (Mesh->Component->Mobility != EComponentMobility::Static);
	MeshInstanceData.NumRelevantLights = Mesh->RelevantLightsGuid.Num();
	MeshInstanceData.BoundingBox = FBox3f(Mesh->BoundingBox);
	Swarm.WriteChannel( Channel, &MeshInstanceData, sizeof(MeshInstanceData) );
	const uint32 LightGuidsSize = Mesh->RelevantLightsGuid.Num() * sizeof(FGuid);
	if( LightGuidsSize > 0 )
	{
		FGuid* LightGuids = (FGuid*)FMemory::Malloc(LightGuidsSize);
		for( int32 LightIdx=0; LightIdx < Mesh->RelevantLightsGuid.Num(); LightIdx++ )
		{
			LightGuids[LightIdx] = Mesh->RelevantLightsGuid[LightIdx];
		}
		Swarm.WriteChannel( Channel, LightGuids, LightGuidsSize );
		FMemory::Free( LightGuids );
	}

	const int32 NumVisibilitiyIds = Mesh->VisibilityIds.Num();
	Swarm.WriteChannel(Channel, &NumVisibilitiyIds, sizeof(NumVisibilitiyIds));
	Swarm.WriteChannel(Channel, Mesh->VisibilityIds.GetData(), Mesh->VisibilityIds.Num() * Mesh->VisibilityIds.GetTypeSize());

	// Always need to have at least one material
	if (MaterialElementData.Num() == 0)
	{
		Lightmass::FMaterialElementData DefaultData;
		GetMaterialHash(UMaterial::GetDefaultMaterial(MD_Surface), DefaultData.MaterialHash);
		MaterialElementData.Add(DefaultData);
	}

	// Write out the materials used by this mesh...
	const int32 NumMaterialElements = MaterialElementData.Num();
	Swarm.WriteChannel(Channel, &NumMaterialElements, sizeof(NumMaterialElements));
	for (int32 MtrlIdx = 0; MtrlIdx < NumMaterialElements; MtrlIdx++)
	{
		Swarm.WriteChannel(Channel, &(MaterialElementData[MtrlIdx]), sizeof(Lightmass::FMaterialElementData));
	}
}

void FLightmassExporter::WriteBaseMappingData( int32 Channel, const FStaticLightingMapping* Mapping )
{
	Lightmass::FStaticLightingMappingData MappingData;
	FMemory::Memzero(&MappingData,sizeof(MappingData));
	MappingData.Guid = Mapping->Mesh->Guid;
	MappingData.StaticLightingMeshInstance = Mapping->Mesh->SourceMeshGuid;
	Swarm.WriteChannel( Channel, &MappingData, sizeof(MappingData) );
}

void FLightmassExporter::WriteBaseTextureMappingData( int32 Channel, const FStaticLightingTextureMapping* TextureMapping )
{
	WriteBaseMappingData( Channel, TextureMapping );
	
	Lightmass::FStaticLightingTextureMappingData TextureMappingData;
	FMemory::Memzero(&TextureMappingData,sizeof(TextureMappingData));
	check(TextureMapping->SizeX > 0 && TextureMapping->SizeY > 0);
	TextureMappingData.SizeX = TextureMapping->SizeX;
	TextureMappingData.SizeY = TextureMapping->SizeY;
	TextureMappingData.LightmapTextureCoordinateIndex = TextureMapping->LightmapTextureCoordinateIndex;
	TextureMappingData.bBilinearFilter = TextureMapping->bBilinearFilter;

	Swarm.WriteChannel( Channel, &TextureMappingData, sizeof(TextureMappingData) );
}


void FLightmassExporter::WriteLandscapeMapping(int32 Channel, const class FLandscapeStaticLightingTextureMapping* LandscapeMapping)
{
	WriteBaseTextureMappingData(Channel, (const FStaticLightingTextureMapping*)LandscapeMapping);
}

struct FMeshAndLODId
{
	int32 MeshIndex;
	int32 LODIndex;
};

void FLightmassExporter::WriteMeshInstances( int32 Channel )
{
	// initially come up with a unique ID for each component
	TMap<const UPrimitiveComponent*, FMeshAndLODId> ComponentToIDMap;

	int32 NextId = 0;
	for( int32 MeshIdx=0; MeshIdx < StaticMeshLightingMeshes.Num(); MeshIdx++ )
	{
		const FStaticMeshStaticLightingMesh* SMLightingMesh = StaticMeshLightingMeshes[MeshIdx];
		const UStaticMesh* StaticMesh = SMLightingMesh->StaticMesh;
		if (StaticMesh)
		{
			const UStaticMeshComponent* Primitive = SMLightingMesh->Primitive;
			if (Primitive)
			{
				// All FStaticMeshStaticLightingMesh's in the OtherMeshLODs array need to get the same MeshIndex but different LODIndex
				// So that they won't shadow each other in Lightmass. HLODs are forced as new meshes and rely on custom handling
				if (SMLightingMesh->HLODTreeIndex)
				{
					FMeshAndLODId NewId;
					NewId.MeshIndex = NextId++;
					NewId.LODIndex = 0;
					ComponentToIDMap.Add(Primitive, NewId);
				}
				else if (SMLightingMesh->OtherMeshLODs.Num() > 0)
				{
					FMeshAndLODId* ExistingLODId = NULL;
					int32 LargestLODIndex = INDEX_NONE;
					for (int32 OtherLODIndex = 0; OtherLODIndex < SMLightingMesh->OtherMeshLODs.Num(); OtherLODIndex++)
					{
						FStaticLightingMesh* OtherLOD = SMLightingMesh->OtherMeshLODs[OtherLODIndex];
						if (OtherLOD->Component)
						{
							FMeshAndLODId* CurrentLODId = ComponentToIDMap.Find(OtherLOD->Component);
							// Find the mesh with the largest index
							if (CurrentLODId && CurrentLODId->LODIndex > LargestLODIndex)
							{
								ExistingLODId = CurrentLODId;
								LargestLODIndex = CurrentLODId->LODIndex;
							}
						}
					}
					if (ExistingLODId)
					{
						FMeshAndLODId NewId;
						// Reuse the mesh index from another LOD
						NewId.MeshIndex = ExistingLODId->MeshIndex;
						// Assign a new unique LOD index
						NewId.LODIndex = ExistingLODId->LODIndex + 1;
						ComponentToIDMap.Add(Primitive, NewId);
					}
					else
					{
						FMeshAndLODId NewId;
						NewId.MeshIndex = NextId++;
						NewId.LODIndex = 0;
						ComponentToIDMap.Add(Primitive, NewId);
					}
				}
				else
				{
					FMeshAndLODId NewId;
					NewId.MeshIndex = NextId++;
					NewId.LODIndex = 0;
					ComponentToIDMap.Add(Primitive, NewId);
				}
			}
		}
	}

	// static mesh instance meshes
	for( int32 MeshIdx=0; MeshIdx < StaticMeshLightingMeshes.Num(); MeshIdx++ )
	{
		const FStaticMeshStaticLightingMesh* SMLightingMesh = StaticMeshLightingMeshes[MeshIdx];

		FMeshAndLODId* MeshId = NULL;

		// Collect the material guids for each element
		TArray<Lightmass::FMaterialElementData> MaterialElementData;
		const UStaticMesh* StaticMesh = SMLightingMesh->StaticMesh;
		check(StaticMesh);

		const UStaticMeshComponent* Primitive = SMLightingMesh->Primitive;
		if (Primitive)
		{
			// get the meshindex from the component
			MeshId = ComponentToIDMap.Find(Primitive);

			if (StaticMesh->GetRenderData() && SMLightingMesh->LODIndex < StaticMesh->GetRenderData()->LODResources.Num())
			{
				const FStaticMeshLODResources& LODRenderData = StaticMesh->GetRenderData()->LODResources[SMLightingMesh->LODIndex];
				for (int32 SectionIndex = 0; SectionIndex < LODRenderData.Sections.Num(); SectionIndex++)
				{
					const FStaticMeshSection& Section = LODRenderData.Sections[ SectionIndex ];
					UMaterialInterface* Material = Primitive->GetMaterial(Section.MaterialIndex);
					if (Material == NULL)
					{
						Material = UMaterial::GetDefaultMaterial(MD_Surface);
					}
					Lightmass::FMaterialElementData NewElementData;
					GetMaterialHash(Material, NewElementData.MaterialHash);
					NewElementData.bUseTwoSidedLighting = Primitive->LightmassSettings.bUseTwoSidedLighting;
					NewElementData.bShadowIndirectOnly = Primitive->LightmassSettings.bShadowIndirectOnly;
					NewElementData.bUseEmissiveForStaticLighting = Primitive->LightmassSettings.bUseEmissiveForStaticLighting;
					NewElementData.bUseVertexNormalForHemisphereGather = Primitive->LightmassSettings.bUseVertexNormalForHemisphereGather;
					// Combine primitive and level boost settings so we don't have to send the level settings over to Lightmass  
					NewElementData.EmissiveLightFalloffExponent = Primitive->LightmassSettings.EmissiveLightFalloffExponent;
					NewElementData.EmissiveLightExplicitInfluenceRadius = Primitive->LightmassSettings.EmissiveLightExplicitInfluenceRadius;
					NewElementData.EmissiveBoost = Primitive->GetEmissiveBoost(SectionIndex) * LevelSettings.EmissiveBoost;
					NewElementData.DiffuseBoost = Primitive->GetDiffuseBoost(SectionIndex) * LevelSettings.DiffuseBoost;
					NewElementData.FullyOccludedSamplesFraction = Primitive->LightmassSettings.FullyOccludedSamplesFraction;
					MaterialElementData.Add(NewElementData);
				}
			}
		}

		WriteBaseMeshInstanceData( Channel, MeshId ? MeshId->MeshIndex : INDEX_NONE, SMLightingMesh, MaterialElementData );

		Lightmass::FStaticMeshStaticLightingMeshData SMInstanceMeshData;
		FMemory::Memzero(&SMInstanceMeshData,sizeof(SMInstanceMeshData));

		// Store HLOD data in upper 16 bits
		SMInstanceMeshData.EncodedLODIndices = SMLightingMesh->LODIndex & 0xFFFF;
		SMInstanceMeshData.EncodedLODIndices |= (SMLightingMesh->HLODTreeIndex & 0xFFFF) << 16;
		SMInstanceMeshData.EncodedHLODRange = SMLightingMesh->HLODChildStartIndex & 0xFFFF;
		SMInstanceMeshData.EncodedHLODRange |= (SMLightingMesh->HLODChildEndIndex & 0xFFFF) << 16;

		SMInstanceMeshData.LocalToWorld = FMatrix44f(SMLightingMesh->LocalToWorld);	// LWC_TODO: Precision loss relevant here?
		SMInstanceMeshData.bReverseWinding = SMLightingMesh->bReverseWinding;
		SMInstanceMeshData.bShouldSelfShadow = true;
		SMInstanceMeshData.StaticMeshGuid = SMLightingMesh->StaticMesh->GetLightingGuid();
		const FSplineMeshParams* SplineParams = SMLightingMesh->GetSplineParameters();
		if (SplineParams && StaticMesh)
		{
			FBoxSphereBounds MeshBounds = StaticMesh->GetBounds();
			const USplineMeshComponent* SplineComponent = CastChecked<USplineMeshComponent>(SMLightingMesh->Component);
			SMInstanceMeshData.bIsSplineMesh = true;
			Copy(*SplineParams, SMInstanceMeshData.SplineParameters);
			SMInstanceMeshData.SplineParameters.SplineUpDir = FVector3f(SplineComponent->SplineUpDir);
			SMInstanceMeshData.SplineParameters.bSmoothInterpRollScale = SplineComponent->bSmoothInterpRollScale;

			if (FMath::IsNearlyEqual(SplineComponent->SplineBoundaryMin, SplineComponent->SplineBoundaryMax))
			{
				// set ranges according to the extents of the mesh
				SMInstanceMeshData.SplineParameters.MeshMinZ = MeshBounds.Origin[SplineComponent->ForwardAxis] - MeshBounds.BoxExtent[SplineComponent->ForwardAxis];
				SMInstanceMeshData.SplineParameters.MeshRangeZ = 2.f * MeshBounds.BoxExtent[SplineComponent->ForwardAxis];
			}
			else
			{
				// set ranges according to the custom boundary min/max
				SMInstanceMeshData.SplineParameters.MeshMinZ = SplineComponent->SplineBoundaryMin;
				SMInstanceMeshData.SplineParameters.MeshRangeZ = SplineComponent->SplineBoundaryMax - SplineComponent->SplineBoundaryMin;
			}

			SMInstanceMeshData.SplineParameters.ForwardAxis = (Lightmass::ESplineMeshAxis::Type)SplineComponent->ForwardAxis.GetValue();
		}
		else
		{
			SMInstanceMeshData.bIsSplineMesh = false;
			FMemory::Memzero(&SMInstanceMeshData.SplineParameters, sizeof(SMInstanceMeshData.SplineParameters));
		}

		Swarm.WriteChannel( Channel, &SMInstanceMeshData, sizeof(SMInstanceMeshData) );

		UpdateExportProgress();
	}
}

void FLightmassExporter::WriteLandscapeInstances( int32 Channel )
{
	// landscape instance meshes
	for (int32 LandscapeIdx = 0; LandscapeIdx < LandscapeLightingMeshes.Num(); LandscapeIdx++)
	{
		const FLandscapeStaticLightingMesh* LandscapeLightingMesh = LandscapeLightingMeshes[LandscapeIdx];

		// Collect the material guids for each element
		TArray<Lightmass::FMaterialElementData> MaterialElementData;
		const ULandscapeComponent* LandscapeComp = LandscapeLightingMesh->LandscapeComponent;
		if (LandscapeComp && LandscapeComp->GetLandscapeProxy())
		{
			UMaterialInterface* Material = LandscapeComp->GetMaterialInstance(0, false);
			if (!Material)
			{
				Material = UMaterial::GetDefaultMaterial(MD_Surface);
			}
			Lightmass::FMaterialElementData NewElementData;
			GetMaterialHash(Material, NewElementData.MaterialHash);
			FLightmassPrimitiveSettings& LMSetting = LandscapeComp->GetLandscapeProxy()->LightmassSettings;
			NewElementData.bUseTwoSidedLighting = LMSetting.bUseTwoSidedLighting;
			NewElementData.bShadowIndirectOnly = LMSetting.bShadowIndirectOnly;
			NewElementData.bUseEmissiveForStaticLighting = LMSetting.bUseEmissiveForStaticLighting;
			NewElementData.bUseVertexNormalForHemisphereGather = LMSetting.bUseVertexNormalForHemisphereGather;
			// Combine primitive and level boost settings so we don't have to send the level settings over to Lightmass  
			NewElementData.EmissiveLightFalloffExponent = LMSetting.EmissiveLightFalloffExponent;
			NewElementData.EmissiveLightExplicitInfluenceRadius = LMSetting.EmissiveLightExplicitInfluenceRadius;
			NewElementData.EmissiveBoost = LandscapeComp->GetEmissiveBoost(0) * LevelSettings.EmissiveBoost;
			NewElementData.DiffuseBoost = LandscapeComp->GetDiffuseBoost(0) * LevelSettings.DiffuseBoost;
			NewElementData.FullyOccludedSamplesFraction = LMSetting.FullyOccludedSamplesFraction;
			MaterialElementData.Add(NewElementData);
		}

		WriteBaseMeshInstanceData(Channel, INDEX_NONE, LandscapeLightingMesh, MaterialElementData);

		Lightmass::FLandscapeStaticLightingMeshData LandscapeInstanceMeshData;
		FMemory::Memzero(&LandscapeInstanceMeshData,sizeof(LandscapeInstanceMeshData));

		LandscapeInstanceMeshData.LocalToWorld = FMatrix44f(LandscapeLightingMesh->LocalToWorld.ToMatrixWithScale());	// LWC_TODO: Precision loss relevant here?
		LandscapeInstanceMeshData.ComponentSizeQuads = LandscapeLightingMesh->ComponentSizeQuads;
		LandscapeInstanceMeshData.LightMapRatio = LandscapeLightingMesh->LightMapRatio;
		LandscapeInstanceMeshData.ExpandQuadsX = LandscapeLightingMesh->ExpandQuadsX;
		LandscapeInstanceMeshData.ExpandQuadsY = LandscapeLightingMesh->ExpandQuadsY;

		Swarm.WriteChannel( Channel, &LandscapeInstanceMeshData, sizeof(LandscapeInstanceMeshData) );

		// write height map data
		uint8* OutData;
		int32 OutSize;

		OutSize = LandscapeLightingMesh->HeightData.Num() * sizeof(FColor);  
		if (OutSize > 0)
		{
			OutData = (uint8*)(LandscapeLightingMesh->HeightData.GetData());
			Swarm.WriteChannel(Channel, OutData, OutSize);
		}

		UpdateExportProgress();
	}
}

struct FLightmassMaterialPair
{
	FLightmassMaterialPair(int32 InLightmassSettingsIndex, UMaterialInterface* InMaterial)
		: LightmassSettingsIndex(InLightmassSettingsIndex)
		, Material(InMaterial)
	{
	}

	/** Index into the Model's LightmassSettings array for this triangle */
	int32 LightmassSettingsIndex;

	/** Materials used by this triangle */
	UMaterialInterface* Material;

	bool operator==( const FLightmassMaterialPair& Other ) const
	{
		return LightmassSettingsIndex == Other.LightmassSettingsIndex && Material == Other.Material;
	}
};


void FLightmassExporter::WriteMappings( int32 Channel )
{
	// bsp mappings
	for( int32 MappingIdx=0; MappingIdx < BSPSurfaceMappings.Num() && !GEditor->GetMapBuildCancelled(); MappingIdx++ )
	{
		const FBSPSurfaceStaticLighting* BSPMapping = BSPSurfaceMappings[MappingIdx];

		TArray<Lightmass::FMaterialElementData> MaterialElementData;
		const UModel* Model = BSPMapping->GetModel();
		check(Model);

		// make a list of the used lightmass settings by this NodeGroup and a mapping from
		// each triangle into this array
		TArray<FLightmassMaterialPair> LocalLightmassSettings;
		TArray<int32> LocalPerTriangleLightmassSettings;

		// go through each triangle, looking for unique settings, and remapping each triangle 
		int32 NumTriangles = BSPMapping->NodeGroup->TriangleSurfaceMap.Num();
		LocalPerTriangleLightmassSettings.Empty(NumTriangles);
		LocalPerTriangleLightmassSettings.AddUninitialized(NumTriangles);
		for (int32 TriangleIndex = 0; TriangleIndex < NumTriangles; TriangleIndex++)
		{
			const FBspSurf& Surf = Model->Surfs[BSPMapping->NodeGroup->TriangleSurfaceMap[TriangleIndex]];
			LocalPerTriangleLightmassSettings[TriangleIndex] = 
				LocalLightmassSettings.AddUnique(FLightmassMaterialPair(Surf.iLightmassIndex, Surf.Material));
		}

		// now for each used setting, export it
		for (int32 SettingIndex = 0; SettingIndex < LocalLightmassSettings.Num(); SettingIndex++)
		{
			const FLightmassMaterialPair& Pair = LocalLightmassSettings[SettingIndex];
			UMaterialInterface* Material = Pair.Material;
			if (Material == NULL)
			{
				Material = UMaterial::GetDefaultMaterial(MD_Surface);
			}
			check(Material);

			// get the settings from the model
			const FLightmassPrimitiveSettings& PrimitiveSettings = Model->LightmassSettings[Pair.LightmassSettingsIndex];

			Lightmass::FMaterialElementData TempData;
			GetMaterialHash(Material, TempData.MaterialHash);
			TempData.bUseTwoSidedLighting = PrimitiveSettings.bUseTwoSidedLighting;
			TempData.bShadowIndirectOnly = PrimitiveSettings.bShadowIndirectOnly;
			TempData.bUseEmissiveForStaticLighting = PrimitiveSettings.bUseEmissiveForStaticLighting;
			TempData.bUseVertexNormalForHemisphereGather = PrimitiveSettings.bUseVertexNormalForHemisphereGather;
			TempData.EmissiveLightFalloffExponent = PrimitiveSettings.EmissiveLightFalloffExponent;
			TempData.EmissiveLightExplicitInfluenceRadius = PrimitiveSettings.EmissiveLightExplicitInfluenceRadius;
			TempData.EmissiveBoost = PrimitiveSettings.EmissiveBoost * LevelSettings.EmissiveBoost;
			TempData.DiffuseBoost = PrimitiveSettings.DiffuseBoost * LevelSettings.DiffuseBoost;
			TempData.FullyOccludedSamplesFraction = PrimitiveSettings.FullyOccludedSamplesFraction;
			MaterialElementData.Add(TempData);
		}
		
		WriteBaseMeshInstanceData(Channel, INDEX_NONE, BSPMapping, MaterialElementData);
		WriteBaseTextureMappingData( Channel, BSPMapping );
		
		Lightmass::FBSPSurfaceStaticLightingData BSPSurfaceMappingData;
		BSPSurfaceMappingData.TangentX = BSPMapping->NodeGroup->TangentX;
		BSPSurfaceMappingData.TangentY = BSPMapping->NodeGroup->TangentY;
		BSPSurfaceMappingData.TangentZ = BSPMapping->NodeGroup->TangentZ;
		BSPSurfaceMappingData.MapToWorld = FMatrix44f(BSPMapping->NodeGroup->MapToWorld);	// LWC_TODO: Precision loss?
		BSPSurfaceMappingData.WorldToMap = FMatrix44f(BSPMapping->NodeGroup->WorldToMap);	// LWC_TODO: Precision loss?
		
		Swarm.WriteChannel( Channel, &BSPSurfaceMappingData, sizeof(BSPSurfaceMappingData) );
	
		const uint32 VertexDataSize = BSPMapping->NodeGroup->Vertices.Num() * sizeof(Lightmass::FStaticLightingVertexData);
		if( VertexDataSize > 0 )
		{
			Lightmass::FStaticLightingVertexData* VertexData = (Lightmass::FStaticLightingVertexData*)FMemory::Malloc(VertexDataSize);
			for( int32 VertIdx=0; VertIdx < BSPMapping->NodeGroup->Vertices.Num(); VertIdx++ )
			{
				const FStaticLightingVertex& SrcVertex = BSPMapping->NodeGroup->Vertices[VertIdx];
				Lightmass::FStaticLightingVertexData& DstVertex = VertexData[VertIdx];

				// LWC_TODO: precision loss
				DstVertex.WorldPosition = (FVector3f)SrcVertex.WorldPosition;
				DstVertex.WorldTangentX = (FVector3f)SrcVertex.WorldTangentX;
				DstVertex.WorldTangentY = (FVector3f)SrcVertex.WorldTangentY;
				DstVertex.WorldTangentZ = (FVector3f)SrcVertex.WorldTangentZ;
				for( int32 CoordIdx=0; CoordIdx < Lightmass::MAX_TEXCOORDS; CoordIdx++ )
				{	
					DstVertex.TextureCoordinates[CoordIdx] = FVector2f(SrcVertex.TextureCoordinates[CoordIdx]);	// LWC_TODO: Precision loss
				}
			}
			Swarm.WriteChannel( Channel, VertexData, VertexDataSize );
			FMemory::Free( VertexData );
		}
		if( BSPMapping->NodeGroup->TriangleVertexIndices.Num() > 0 )
		{
			Swarm.WriteChannel( Channel, (void*)BSPMapping->NodeGroup->TriangleVertexIndices.GetData(), BSPMapping->NodeGroup->TriangleVertexIndices.Num() * sizeof(int32) );
		}

		Swarm.WriteChannel(Channel, LocalPerTriangleLightmassSettings.GetData(), LocalPerTriangleLightmassSettings.Num() * sizeof(int32));
		UpdateExportProgress();
	}	
	
	// static mesh texture mappings
	for( int32 MappingIdx=0; MappingIdx < StaticMeshTextureMappings.Num(); MappingIdx++ )
	{
		const FStaticMeshStaticLightingTextureMapping* SMTextureMapping = StaticMeshTextureMappings[MappingIdx];
		WriteBaseTextureMappingData( Channel, SMTextureMapping );
		UpdateExportProgress();
	}	

	// landscape surface mappings
	for (int32 MappingIdx = 0; MappingIdx < LandscapeTextureMappings.Num(); MappingIdx++)
	{
		const FLandscapeStaticLightingTextureMapping* LandscapeMapping = LandscapeTextureMappings[MappingIdx];
		WriteLandscapeMapping(Channel, LandscapeMapping);
		UpdateExportProgress();
	}

	for (int32 MappingIdx = 0; MappingIdx < VolumeMappings.Num(); MappingIdx++)
	{
		const FStaticLightingGlobalVolumeMapping* VolumeMapping = VolumeMappings[MappingIdx];
		WriteBaseTextureMappingData( Channel, VolumeMapping );
		UpdateExportProgress();
	}

	for (int32 MappingIdx = 0; MappingIdx < LandscapeVolumeMappings.Num(); MappingIdx++)
	{
		const FLandscapeStaticLightingGlobalVolumeMapping* VolumeMapping = LandscapeVolumeMappings[MappingIdx];
		WriteLandscapeMapping( Channel, VolumeMapping );
		UpdateExportProgress();
	}
}

/** Finds the GUID of the mapping that is being debugged. */
bool FLightmassExporter::FindDebugMapping(FGuid& DebugMappingGuid)
{
	const FStaticLightingMapping* FoundDebugMapping = NULL;
	// Only BSP texture, static mesh vertex and texture lightmaps supported for now.
	for( int32 MappingIdx=0; MappingIdx < BSPSurfaceMappings.Num(); MappingIdx++ )
	{
		const FBSPSurfaceStaticLighting* BSPMapping = BSPSurfaceMappings[MappingIdx];
		if (BSPMapping->DebugThisMapping())
		{
			// Only one mapping should be setup for debugging
			check(!FoundDebugMapping);
			FoundDebugMapping = BSPMapping;
		}
	}

	for( int32 MappingIdx=0; MappingIdx < StaticMeshTextureMappings.Num(); MappingIdx++ )
	{
		const FStaticMeshStaticLightingTextureMapping* SMTextureMapping = StaticMeshTextureMappings[MappingIdx];
		if (SMTextureMapping->DebugThisMapping())
		{
			// Only one mapping should be setup for debugging
			check(!FoundDebugMapping);
			FoundDebugMapping = SMTextureMapping;
		}
	}	

	if (FoundDebugMapping)
	{
		DebugMappingGuid = FoundDebugMapping->GetLightingGuid();
		return true;
	}
	else 
	{
		return false;
	}
}

void FLightmassExporter::SetVolumetricLightmapSettings(Lightmass::FVolumetricLightmapSettings& OutSettings)
{
	FBox CombinedImportanceVolume(ForceInit);

	for (int32 i = 0; i < ImportanceVolumes.Num(); i++)
	{
		CombinedImportanceVolume += ImportanceVolumes[i];
	}

	const FVector ImportanceExtent = CombinedImportanceVolume.GetExtent();
	// Guarantee cube voxels.  
	// This means some parts of the volumetric lightmap volume will be outside the lightmass importance volume.
	// We prevent refinement outside of importance volumes in FStaticLightingSystem::ShouldRefineVoxel
	const float MaxExtent = FMath::Max(ImportanceExtent.X, FMath::Max(ImportanceExtent.Y, ImportanceExtent.Z));

	OutSettings.VolumeMin = FVector3f(CombinedImportanceVolume.Min);	//LWC_TODO: Precision loss
	const FVector RequiredVolumeSize = FVector(MaxExtent * 2);

	VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.VolumetricLightmaps"), TEXT("BrickSize"), OutSettings.BrickSize, GLightmassIni));
	VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.VolumetricLightmaps"), TEXT("MaxRefinementLevels"), OutSettings.MaxRefinementLevels, GLightmassIni));
	VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.VolumetricLightmaps"), TEXT("VoxelizationCellExpansionForSurfaceGeometry"), OutSettings.VoxelizationCellExpansionForSurfaceGeometry, GLightmassIni));
	VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.VolumetricLightmaps"), TEXT("VoxelizationCellExpansionForVolumeGeometry"), OutSettings.VoxelizationCellExpansionForVolumeGeometry, GLightmassIni));
	VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.VolumetricLightmaps"), TEXT("VoxelizationCellExpansionForLights"), OutSettings.VoxelizationCellExpansionForLights, GLightmassIni));
	VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.VolumetricLightmaps"), TEXT("MinBrickError"), OutSettings.MinBrickError, GLightmassIni));
	VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.VolumetricLightmaps"), TEXT("SurfaceLightmapMinTexelsPerVoxelAxis"), OutSettings.SurfaceLightmapMinTexelsPerVoxelAxis, GLightmassIni));
	VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.VolumetricLightmaps"), TEXT("bCullBricksBelowLandscape"), OutSettings.bCullBricksBelowLandscape, GLightmassIni));
	VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.VolumetricLightmaps"), TEXT("LightBrightnessSubdivideThreshold"), OutSettings.LightBrightnessSubdivideThreshold, GLightmassIni));

	const FLightmassWorldInfoSettings& WorldInfoSettings = World->GetWorldSettings()->LightmassSettings;

	float Smoothing = FMath::Clamp(WorldInfoSettings.VolumetricLightmapSphericalHarmonicSmoothing, SMALL_NUMBER, 1000.0f);
	OutSettings.WindowingTargetLaplacian = 1.0f / Smoothing;

	OutSettings.BrickSize = FMath::RoundUpToPowerOfTwo(OutSettings.BrickSize);
	OutSettings.MaxRefinementLevels = FMath::Clamp(OutSettings.MaxRefinementLevels, 1, 6);
	OutSettings.VoxelizationCellExpansionForSurfaceGeometry = FMath::Max(OutSettings.VoxelizationCellExpansionForSurfaceGeometry, 0.0f);
	OutSettings.VoxelizationCellExpansionForVolumeGeometry = FMath::Max(OutSettings.VoxelizationCellExpansionForVolumeGeometry, 0.0f);
	OutSettings.VoxelizationCellExpansionForLights = FMath::Max(OutSettings.VoxelizationCellExpansionForLights, 0.0f);

	const float TargetDetailCellSize = WorldInfoSettings.VolumetricLightmapDetailCellSize;

	FIntVector FullGridSize(
		FMath::TruncToInt(2 * ImportanceExtent.X / TargetDetailCellSize) + 1,
		FMath::TruncToInt(2 * ImportanceExtent.Y / TargetDetailCellSize) + 1,
		FMath::TruncToInt(2 * ImportanceExtent.Z / TargetDetailCellSize) + 1);

	// Make sure size of indirection texture does not exceed INT_MAX
	const int32 MaxGridDimension = FMath::Pow(2048000000 / 4, 1.0f / 3) * OutSettings.BrickSize;
	if (FullGridSize.GetMax() > MaxGridDimension)
	{
		UE_LOG(LogLightmassSolver, Warning, 
			TEXT("Volumetric lightmap grid size is too large which can cause potential crashes or long build time, clamping from (%d, %d, %d) to (%d, %d, %d)"),
			FullGridSize.X,
			FullGridSize.Y,
			FullGridSize.Z,
			FMath::Min(FullGridSize.X, MaxGridDimension),
			FMath::Min(FullGridSize.Y, MaxGridDimension),
			FMath::Min(FullGridSize.Z, MaxGridDimension)
			);
		FullGridSize.X = FMath::Min(FullGridSize.X, MaxGridDimension);
		FullGridSize.Y = FMath::Min(FullGridSize.Y, MaxGridDimension);
		FullGridSize.Z = FMath::Min(FullGridSize.Z, MaxGridDimension);
	}

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

	OutSettings.TopLevelGridSize = FIntVector::DivideAndRoundUp(FullGridSize, DetailCellsPerTopLevelBrick);

	OutSettings.VolumeSize = FVector3f(OutSettings.TopLevelGridSize) * DetailCellsPerTopLevelBrick * TargetDetailCellSize;
}

/** Fills out the Scene's settings, read from the engine ini. */
void FLightmassExporter::WriteSceneSettings( Lightmass::FSceneFileHeader& Scene )
{
	bool bConfigBool = false;
	//@todo - need a mechanism to automatically catch when a new setting has been added but doesn't get initialized
	{
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bAllowMultiThreadedStaticLighting"), bConfigBool, GLightmassIni));
		Scene.GeneralSettings.bAllowMultiThreadedStaticLighting = bConfigBool;
		Scene.GeneralSettings.NumUnusedLocalCores = NumUnusedLocalCores;
		Scene.GeneralSettings.NumIndirectLightingBounces = LevelSettings.NumIndirectLightingBounces;
		Scene.GeneralSettings.NumSkyLightingBounces = LevelSettings.NumSkyLightingBounces;
		Scene.GeneralSettings.IndirectLightingSmoothness = LevelSettings.IndirectLightingSmoothness;
		Scene.GeneralSettings.IndirectLightingQuality = LevelSettings.IndirectLightingQuality;

		if (QualityLevel == Quality_Preview)
		{
			Scene.GeneralSettings.IndirectLightingQuality = FMath::Min(Scene.GeneralSettings.IndirectLightingQuality, 1.0f);
		}

		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticLighting"), TEXT("ViewSingleBounceNumber"), Scene.GeneralSettings.ViewSingleBounceNumber, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bUseConservativeTexelRasterization"), bConfigBool, GLightmassIni));
		Scene.GeneralSettings.bUseConservativeTexelRasterization = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bAccountForTexelSize"), bConfigBool, GLightmassIni));
		Scene.GeneralSettings.bAccountForTexelSize = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bUseMaxWeight"), bConfigBool, GLightmassIni));
		Scene.GeneralSettings.bUseMaxWeight = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticLighting"), TEXT("MaxTriangleLightingSamples"), Scene.GeneralSettings.MaxTriangleLightingSamples, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticLighting"), TEXT("MaxTriangleIrradiancePhotonCacheSamples"), Scene.GeneralSettings.MaxTriangleIrradiancePhotonCacheSamples, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bUseEmbree"), bConfigBool, GLightmassIni));
		Scene.GeneralSettings.bUseEmbree = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bVerifyEmbree"), bConfigBool, GLightmassIni));
		Scene.GeneralSettings.bVerifyEmbree = Scene.GeneralSettings.bUseEmbree && bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bUseEmbreePacketTracing"), Scene.GeneralSettings.bUseEmbreePacketTracing, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bUseFastVoxelization"), Scene.GeneralSettings.bUseFastVoxelization, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bUseEmbreeInstancing"), Scene.GeneralSettings.bUseEmbreeInstancing, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticLighting"), TEXT("MappingSurfaceCacheDownsampleFactor"), Scene.GeneralSettings.MappingSurfaceCacheDownsampleFactor, GLightmassIni));

		int32 CheckQualityLevel;
		GConfig->GetInt( TEXT("LightingBuildOptions"), TEXT("QualityLevel"), CheckQualityLevel, GEditorPerProjectIni);
		CheckQualityLevel = FMath::Clamp<int32>(CheckQualityLevel, Quality_Preview, Quality_Production);
		UE_LOG(LogLightmassSolver, Log, TEXT("LIGHTMASS: Writing scene settings: Quality level %d (%d in INI)"), (int32)(QualityLevel), CheckQualityLevel);
		if (CheckQualityLevel != QualityLevel)
		{
			UE_LOG(LogLightmassSolver, Warning, TEXT("LIGHTMASS: Writing scene settings w/ QualityLevel mismatch! %d vs %d (ini setting)"), (int32)QualityLevel, CheckQualityLevel);
		}

		switch (QualityLevel)
		{
		case Quality_High:
		case Quality_Production:
			Scene.GeneralSettings.bUseErrorColoring = false;
			Scene.GeneralSettings.UnmappedTexelColor = FLinearColor(0.0f, 0.0f, 0.0f);
			break;
		default:
			{
				bool bUseErrorColoring = false;
				GConfig->GetBool( TEXT("LightingBuildOptions"), TEXT("UseErrorColoring"),		bUseErrorColoring,					GEditorPerProjectIni );
				Scene.GeneralSettings.bUseErrorColoring = bUseErrorColoring;
				if (bUseErrorColoring == false)
				{
					Scene.GeneralSettings.UnmappedTexelColor = FLinearColor(0.0f, 0.0f, 0.0f);
				}
				else
				{
					Scene.GeneralSettings.UnmappedTexelColor = FLinearColor(0.7f, 0.7f, 0.0f);
				}
			}
			break;
		}
	}
	{
		float GlobalLevelScale = 1.0f;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticLightingSceneConstants"), TEXT("StaticLightingLevelScale"), GlobalLevelScale, GLightmassIni));
		Scene.SceneConstants.StaticLightingLevelScale = GlobalLevelScale * LevelSettings.StaticLightingLevelScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticLightingSceneConstants"), TEXT("VisibilityRayOffsetDistance"), Scene.SceneConstants.VisibilityRayOffsetDistance, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticLightingSceneConstants"), TEXT("VisibilityNormalOffsetDistance"), Scene.SceneConstants.VisibilityNormalOffsetDistance, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticLightingSceneConstants"), TEXT("VisibilityNormalOffsetSampleRadiusScale"), Scene.SceneConstants.VisibilityNormalOffsetSampleRadiusScale, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticLightingSceneConstants"), TEXT("VisibilityTangentOffsetSampleRadiusScale"), Scene.SceneConstants.VisibilityTangentOffsetSampleRadiusScale, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticLightingSceneConstants"), TEXT("SmallestTexelRadius"), Scene.SceneConstants.SmallestTexelRadius, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticLightingSceneConstants"), TEXT("LightGridSize"), Scene.SceneConstants.LightGridSize, GLightmassIni));
	}
	{
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLightingMaterial"), TEXT("bUseDebugMaterial"), bConfigBool, GLightmassIni));
		Scene.MaterialSettings.bUseDebugMaterial = bConfigBool;
		FString ShowMaterialAttributeName;
		VERIFYLIGHTMASSINI(GConfig->GetString(TEXT("DevOptions.StaticLightingMaterial"), TEXT("ShowMaterialAttribute"), ShowMaterialAttributeName, GLightmassIni));

		Scene.MaterialSettings.ViewMaterialAttribute = Lightmass::VMA_None;
		if (ShowMaterialAttributeName.Contains(TEXT("Emissive")) )
		{
			Scene.MaterialSettings.ViewMaterialAttribute = Lightmass::VMA_Emissive;
		}
		else if (ShowMaterialAttributeName.Contains(TEXT("Diffuse"))
			|| LevelSettings.bVisualizeMaterialDiffuse)
		{
			Scene.MaterialSettings.ViewMaterialAttribute = Lightmass::VMA_Diffuse;
		}
		else if (ShowMaterialAttributeName.Contains(TEXT("Transmission")) )
		{
			Scene.MaterialSettings.ViewMaterialAttribute = Lightmass::VMA_Transmission;
		}
		else if (ShowMaterialAttributeName.Contains(TEXT("Normal")) )
		{
			Scene.MaterialSettings.ViewMaterialAttribute = Lightmass::VMA_Normal;
		}

		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticLightingMaterial"), TEXT("EmissiveSampleSize"), Scene.MaterialSettings.EmissiveSize, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticLightingMaterial"), TEXT("DiffuseSampleSize"), Scene.MaterialSettings.DiffuseSize, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticLightingMaterial"), TEXT("TransmissionSampleSize"), Scene.MaterialSettings.TransmissionSize, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticLightingMaterial"), TEXT("NormalSampleSize"), Scene.MaterialSettings.NormalSize, GLightmassIni));

		const FString DiffuseStr = GConfig->GetStr(TEXT("DevOptions.StaticLightingMaterial"), TEXT("DebugDiffuse"), GLightmassIni);
		VERIFYLIGHTMASSINI(FParse::Value(*DiffuseStr, TEXT("R="), Scene.MaterialSettings.DebugDiffuse.R));
		VERIFYLIGHTMASSINI(FParse::Value(*DiffuseStr, TEXT("G="), Scene.MaterialSettings.DebugDiffuse.G));
		VERIFYLIGHTMASSINI(FParse::Value(*DiffuseStr, TEXT("B="), Scene.MaterialSettings.DebugDiffuse.B));

		Scene.MaterialSettings.EnvironmentColor = FLinearColor(LevelSettings.EnvironmentColor) * LevelSettings.EnvironmentIntensity;

		static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.NormalMapsForStaticLighting"));
		Scene.MaterialSettings.bUseNormalMapsForLighting = CVar->GetValueOnGameThread() != 0;
	}
	{
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.MeshAreaLights"), TEXT("bVisualizeMeshAreaLightPrimitives"), bConfigBool, GLightmassIni));
		Scene.MeshAreaLightSettings.bVisualizeMeshAreaLightPrimitives = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.MeshAreaLights"), TEXT("EmissiveIntensityThreshold"), Scene.MeshAreaLightSettings.EmissiveIntensityThreshold, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.MeshAreaLights"), TEXT("MeshAreaLightGridSize"), Scene.MeshAreaLightSettings.MeshAreaLightGridSize, GLightmassIni));
		float MeshAreaLightSimplifyNormalAngleThreshold;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.MeshAreaLights"), TEXT("MeshAreaLightSimplifyNormalAngleThreshold"), MeshAreaLightSimplifyNormalAngleThreshold, GLightmassIni));
		Scene.MeshAreaLightSettings.MeshAreaLightSimplifyNormalCosAngleThreshold = FMath::Cos(FMath::Clamp(MeshAreaLightSimplifyNormalAngleThreshold, 0.0f, 90.0f) * (float)PI / 180.0f);
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.MeshAreaLights"), TEXT("MeshAreaLightSimplifyCornerDistanceThreshold"), Scene.MeshAreaLightSettings.MeshAreaLightSimplifyCornerDistanceThreshold, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.MeshAreaLights"), TEXT("MeshAreaLightSimplifyMeshBoundingRadiusFractionThreshold"), Scene.MeshAreaLightSettings.MeshAreaLightSimplifyMeshBoundingRadiusFractionThreshold, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.MeshAreaLights"), TEXT("MeshAreaLightGeneratedDynamicLightSurfaceOffset"), Scene.MeshAreaLightSettings.MeshAreaLightGeneratedDynamicLightSurfaceOffset, GLightmassIni));
	}
	{
		Scene.AmbientOcclusionSettings.bUseAmbientOcclusion = LevelSettings.bUseAmbientOcclusion;
		Scene.AmbientOcclusionSettings.bGenerateAmbientOcclusionMaterialMask = LevelSettings.bGenerateAmbientOcclusionMaterialMask;
		Scene.AmbientOcclusionSettings.bVisualizeAmbientOcclusion = LevelSettings.bVisualizeAmbientOcclusion;
		Scene.AmbientOcclusionSettings.DirectIlluminationOcclusionFraction = LevelSettings.DirectIlluminationOcclusionFraction;
		Scene.AmbientOcclusionSettings.IndirectIlluminationOcclusionFraction = LevelSettings.IndirectIlluminationOcclusionFraction;
		Scene.AmbientOcclusionSettings.OcclusionExponent = LevelSettings.OcclusionExponent;
		Scene.AmbientOcclusionSettings.FullyOccludedSamplesFraction = LevelSettings.FullyOccludedSamplesFraction;
		Scene.AmbientOcclusionSettings.MaxOcclusionDistance = LevelSettings.MaxOcclusionDistance;
	}
	{
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("bVisualizeVolumeLightSamples"), bConfigBool, GLightmassIni));
		Scene.DynamicObjectSettings.bVisualizeVolumeLightSamples = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("bVisualizeVolumeLightInterpolation"), bConfigBool, GLightmassIni));
		Scene.DynamicObjectSettings.bVisualizeVolumeLightInterpolation = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("NumHemisphereSamplesScale"), Scene.DynamicObjectSettings.NumHemisphereSamplesScale, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("SurfaceLightSampleSpacing"), Scene.DynamicObjectSettings.SurfaceLightSampleSpacing, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("FirstSurfaceSampleLayerHeight"), Scene.DynamicObjectSettings.FirstSurfaceSampleLayerHeight, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("SurfaceSampleLayerHeightSpacing"), Scene.DynamicObjectSettings.SurfaceSampleLayerHeightSpacing, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("NumSurfaceSampleLayers"), Scene.DynamicObjectSettings.NumSurfaceSampleLayers, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("DetailVolumeSampleSpacing"), Scene.DynamicObjectSettings.DetailVolumeSampleSpacing, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("VolumeLightSampleSpacing"), Scene.DynamicObjectSettings.VolumeLightSampleSpacing, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("MaxVolumeSamples"), Scene.DynamicObjectSettings.MaxVolumeSamples, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("bUseMaxSurfaceSampleNum"), bConfigBool, GLightmassIni));
		Scene.DynamicObjectSettings.bUseMaxSurfaceSampleNum = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedDynamicObjectLighting"), TEXT("MaxSurfaceLightSamples"), Scene.DynamicObjectSettings.MaxSurfaceLightSamples, GLightmassIni));

		Scene.DynamicObjectSettings.SurfaceLightSampleSpacing *= LevelSettings.VolumeLightSamplePlacementScale;
		Scene.DynamicObjectSettings.VolumeLightSampleSpacing *= LevelSettings.VolumeLightSamplePlacementScale;
		Scene.DynamicObjectSettings.DetailVolumeSampleSpacing *= LevelSettings.VolumeLightSamplePlacementScale;
	}
	{
		SetVolumetricLightmapSettings(Scene.VolumetricLightmapSettings);
	}
	{
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PrecomputedVisibility"), TEXT("bVisualizePrecomputedVisibility"), bConfigBool, GLightmassIni));
		Scene.PrecomputedVisibilitySettings.bVisualizePrecomputedVisibility = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PrecomputedVisibility"), TEXT("bPlaceCellsOnOpaqueOnly"), bConfigBool, GLightmassIni));
		Scene.PrecomputedVisibilitySettings.bPlaceCellsOnOpaqueOnly = bConfigBool;
		Scene.PrecomputedVisibilitySettings.bPlaceCellsOnlyAlongCameraTracks = World->GetWorldSettings()->bPlaceCellsOnlyAlongCameraTracks;
		Scene.PrecomputedVisibilitySettings.CellSize = World->GetWorldSettings()->VisibilityCellSize;
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedVisibility"), TEXT("NumCellDistributionBuckets"), Scene.PrecomputedVisibilitySettings.NumCellDistributionBuckets, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PrecomputedVisibility"), TEXT("PlayAreaHeight"), Scene.PrecomputedVisibilitySettings.PlayAreaHeight, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PrecomputedVisibility"), TEXT("MeshBoundsScale"), Scene.PrecomputedVisibilitySettings.MeshBoundsScale, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedVisibility"), TEXT("MinMeshSamples"), Scene.PrecomputedVisibilitySettings.MinMeshSamples, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedVisibility"), TEXT("MaxMeshSamples"), Scene.PrecomputedVisibilitySettings.MaxMeshSamples, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedVisibility"), TEXT("NumCellSamples"), Scene.PrecomputedVisibilitySettings.NumCellSamples, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedVisibility"), TEXT("NumImportanceSamples"), Scene.PrecomputedVisibilitySettings.NumImportanceSamples, GLightmassIni));
	}
	if (World->GetWorldSettings()->VisibilityAggressiveness != VIS_LeastAggressive)
	{
		const TCHAR* AggressivenessSectionNames[VIS_Max] = {
			TEXT(""), 
			TEXT("DevOptions.PrecomputedVisibilityModeratelyAggressive"), 
			TEXT("DevOptions.PrecomputedVisibilityMostAggressive")};
		const TCHAR* ActiveSection = AggressivenessSectionNames[FMath::Clamp((int32)World->GetWorldSettings()->VisibilityAggressiveness, 0, VIS_Max - 1)];
		VERIFYLIGHTMASSINI(GConfig->GetFloat(ActiveSection, TEXT("MeshBoundsScale"), Scene.PrecomputedVisibilitySettings.MeshBoundsScale, GLightmassIni));
	}
	{
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.VolumeDistanceField"), TEXT("VoxelSize"), Scene.VolumeDistanceFieldSettings.VoxelSize, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.VolumeDistanceField"), TEXT("VolumeMaxDistance"), Scene.VolumeDistanceFieldSettings.VolumeMaxDistance, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.VolumeDistanceField"), TEXT("NumVoxelDistanceSamples"), Scene.VolumeDistanceFieldSettings.NumVoxelDistanceSamples, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.VolumeDistanceField"), TEXT("MaxVoxels"), Scene.VolumeDistanceFieldSettings.MaxVoxels, GLightmassIni));
	}
	{
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticShadows"), TEXT("bUseZeroAreaLightmapSpaceFilteredLights"), bConfigBool, GLightmassIni));
		Scene.ShadowSettings.bUseZeroAreaLightmapSpaceFilteredLights = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticShadows"), TEXT("NumShadowRays"), Scene.ShadowSettings.NumShadowRays, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticShadows"), TEXT("NumPenumbraShadowRays"), Scene.ShadowSettings.NumPenumbraShadowRays, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticShadows"), TEXT("NumBounceShadowRays"), Scene.ShadowSettings.NumBounceShadowRays, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticShadows"), TEXT("bFilterShadowFactor"), bConfigBool, GLightmassIni));
		Scene.ShadowSettings.bFilterShadowFactor = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticShadows"), TEXT("ShadowFactorGradientTolerance"), Scene.ShadowSettings.ShadowFactorGradientTolerance, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticShadows"), TEXT("bAllowSignedDistanceFieldShadows"), bConfigBool, GLightmassIni));
		Scene.ShadowSettings.bAllowSignedDistanceFieldShadows = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticShadows"), TEXT("MaxTransitionDistanceWorldSpace"), Scene.ShadowSettings.MaxTransitionDistanceWorldSpace, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticShadows"), TEXT("ApproximateHighResTexelsPerMaxTransitionDistance"), Scene.ShadowSettings.ApproximateHighResTexelsPerMaxTransitionDistance, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticShadows"), TEXT("MinDistanceFieldUpsampleFactor"), Scene.ShadowSettings.MinDistanceFieldUpsampleFactor, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticShadows"), TEXT("StaticShadowDepthMapTransitionSampleDistanceX"), Scene.ShadowSettings.StaticShadowDepthMapTransitionSampleDistanceX, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticShadows"), TEXT("StaticShadowDepthMapTransitionSampleDistanceY"), Scene.ShadowSettings.StaticShadowDepthMapTransitionSampleDistanceY, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticShadows"), TEXT("StaticShadowDepthMapSuperSampleFactor"), Scene.ShadowSettings.StaticShadowDepthMapSuperSampleFactor, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.StaticShadows"), TEXT("StaticShadowDepthMapMaxSamples"), Scene.ShadowSettings.StaticShadowDepthMapMaxSamples, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.StaticShadows"), TEXT("MinUnoccludedFraction"), Scene.ShadowSettings.MinUnoccludedFraction, GLightmassIni));
	}
	{
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.ImportanceTracing"), TEXT("bUseStratifiedSampling"), bConfigBool, GLightmassIni));
		Scene.ImportanceTracingSettings.bUseStratifiedSampling = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.ImportanceTracing"), TEXT("NumHemisphereSamples"), Scene.ImportanceTracingSettings.NumHemisphereSamples, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.ImportanceTracing"), TEXT("NumAdaptiveRefinementLevels"), Scene.ImportanceTracingSettings.NumAdaptiveRefinementLevels, GLightmassIni));
		float MaxHemisphereAngleDegrees;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.ImportanceTracing"), TEXT("MaxHemisphereRayAngle"), MaxHemisphereAngleDegrees, GLightmassIni));
		Scene.ImportanceTracingSettings.MaxHemisphereRayAngle = MaxHemisphereAngleDegrees * (float)PI / 180.0f;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.ImportanceTracing"), TEXT("AdaptiveBrightnessThreshold"), Scene.ImportanceTracingSettings.AdaptiveBrightnessThreshold, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.ImportanceTracing"), TEXT("AdaptiveFirstBouncePhotonConeAngle"), Scene.ImportanceTracingSettings.AdaptiveFirstBouncePhotonConeAngle, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.ImportanceTracing"), TEXT("AdaptiveSkyVarianceThreshold"), Scene.ImportanceTracingSettings.AdaptiveSkyVarianceThreshold, GLightmassIni));

		float AdaptiveFirstBouncePhotonConeAngle;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.ImportanceTracing"), TEXT("AdaptiveFirstBouncePhotonConeAngle"), AdaptiveFirstBouncePhotonConeAngle, GLightmassIni));
		Scene.ImportanceTracingSettings.AdaptiveFirstBouncePhotonConeAngle = FMath::Clamp(AdaptiveFirstBouncePhotonConeAngle, 0.0f, 90.0f) * (float)PI / 180.0f;

		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.ImportanceTracing"), TEXT("bUseRadiositySolverForSkylightMultibounce"), Scene.ImportanceTracingSettings.bUseRadiositySolverForSkylightMultibounce, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.ImportanceTracing"), TEXT("bCacheFinalGatherHitPointsForRadiosity"), Scene.ImportanceTracingSettings.bCacheFinalGatherHitPointsForRadiosity, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.ImportanceTracing"), TEXT("bUseRadiositySolverForLightMultibounce"), Scene.ImportanceTracingSettings.bUseRadiositySolverForLightMultibounce, GLightmassIni));
	}
	{
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bUsePhotonMapping"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bUsePhotonMapping = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bUseFinalGathering"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bUseFinalGathering = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bUsePhotonDirectLightingInFinalGather"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bUsePhotonDirectLightingInFinalGather = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bVisualizeCachedApproximateDirectLighting"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bVisualizeCachedApproximateDirectLighting = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bUseIrradiancePhotons"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bUseIrradiancePhotons = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bCacheIrradiancePhotonsOnSurfaces"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bCacheIrradiancePhotonsOnSurfaces = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bVisualizePhotonPaths"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bVisualizePhotonPaths = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bVisualizePhotonGathers"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bVisualizePhotonGathers = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bVisualizePhotonImportanceSamples"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bVisualizePhotonImportanceSamples = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bVisualizeIrradiancePhotonCalculation"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bVisualizeIrradiancePhotonCalculation = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bEmitPhotonsOutsideImportanceVolume"), bConfigBool, GLightmassIni));
		Scene.PhotonMappingSettings.bEmitPhotonsOutsideImportanceVolume = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("ConeFilterConstant"), Scene.PhotonMappingSettings.ConeFilterConstant, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PhotonMapping"), TEXT("NumIrradianceCalculationPhotons"), Scene.PhotonMappingSettings.NumIrradianceCalculationPhotons, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("FinalGatherImportanceSampleFraction"), Scene.PhotonMappingSettings.FinalGatherImportanceSampleFraction, GLightmassIni));
		float FinalGatherImportanceSampleConeAngle;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("FinalGatherImportanceSampleConeAngle"), FinalGatherImportanceSampleConeAngle, GLightmassIni));
		Scene.PhotonMappingSettings.FinalGatherImportanceSampleCosConeAngle = FMath::Cos(FMath::Clamp(FinalGatherImportanceSampleConeAngle, 0.0f, 90.0f) * (float)PI / 180.0f);
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("IndirectPhotonEmitDiskRadius"), Scene.PhotonMappingSettings.IndirectPhotonEmitDiskRadius, GLightmassIni));
		float IndirectPhotonEmitConeAngleDegrees;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("IndirectPhotonEmitConeAngle"), IndirectPhotonEmitConeAngleDegrees, GLightmassIni));
		Scene.PhotonMappingSettings.IndirectPhotonEmitConeAngle = FMath::Clamp(IndirectPhotonEmitConeAngleDegrees, 0.0f, 90.0f) * (float)PI / 180.0f;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("MaxImportancePhotonSearchDistance"), Scene.PhotonMappingSettings.MaxImportancePhotonSearchDistance, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("MinImportancePhotonSearchDistance"), Scene.PhotonMappingSettings.MinImportancePhotonSearchDistance, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PhotonMapping"), TEXT("NumImportanceSearchPhotons"), Scene.PhotonMappingSettings.NumImportanceSearchPhotons, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("OutsideImportanceVolumeDensityScale"), Scene.PhotonMappingSettings.OutsideImportanceVolumeDensityScale, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("DirectPhotonDensity"), Scene.PhotonMappingSettings.DirectPhotonDensity, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("DirectIrradiancePhotonDensity"), Scene.PhotonMappingSettings.DirectIrradiancePhotonDensity, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("DirectPhotonSearchDistance"), Scene.PhotonMappingSettings.DirectPhotonSearchDistance, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("IndirectPhotonPathDensity"), Scene.PhotonMappingSettings.IndirectPhotonPathDensity, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("IndirectPhotonDensity"), Scene.PhotonMappingSettings.IndirectPhotonDensity, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("IndirectIrradiancePhotonDensity"), Scene.PhotonMappingSettings.IndirectIrradiancePhotonDensity, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("IndirectPhotonSearchDistance"), Scene.PhotonMappingSettings.IndirectPhotonSearchDistance, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("PhotonSearchAngleThreshold"), Scene.PhotonMappingSettings.PhotonSearchAngleThreshold, GLightmassIni));
		float IrradiancePhotonSearchConeAngle;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("IrradiancePhotonSearchConeAngle"), IrradiancePhotonSearchConeAngle, GLightmassIni));
		Scene.PhotonMappingSettings.MinCosIrradiancePhotonSearchCone = FMath::Cos((90.0f - FMath::Clamp(IrradiancePhotonSearchConeAngle, 1.0f, 90.0f)) * (float)PI / 180.0f);
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PhotonMapping"), TEXT("bUsePhotonSegmentsForVolumeLighting"), Scene.PhotonMappingSettings.bUsePhotonSegmentsForVolumeLighting, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("PhotonSegmentMaxLength"), Scene.PhotonMappingSettings.PhotonSegmentMaxLength, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PhotonMapping"), TEXT("GeneratePhotonSegmentChance"), Scene.PhotonMappingSettings.GeneratePhotonSegmentChance, GLightmassIni));
	}
	{
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.IrradianceCache"), TEXT("bAllowIrradianceCaching"), bConfigBool, GLightmassIni));
		Scene.IrradianceCachingSettings.bAllowIrradianceCaching = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.IrradianceCache"), TEXT("bUseIrradianceGradients"), bConfigBool, GLightmassIni));
		Scene.IrradianceCachingSettings.bUseIrradianceGradients = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.IrradianceCache"), TEXT("bShowGradientsOnly"), bConfigBool, GLightmassIni));
		Scene.IrradianceCachingSettings.bShowGradientsOnly = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.IrradianceCache"), TEXT("bVisualizeIrradianceSamples"), bConfigBool, GLightmassIni));
		Scene.IrradianceCachingSettings.bVisualizeIrradianceSamples = bConfigBool;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.IrradianceCache"), TEXT("RecordRadiusScale"), Scene.IrradianceCachingSettings.RecordRadiusScale, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.IrradianceCache"), TEXT("InterpolationMaxAngle"), Scene.IrradianceCachingSettings.InterpolationMaxAngle, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.IrradianceCache"), TEXT("PointBehindRecordMaxAngle"), Scene.IrradianceCachingSettings.PointBehindRecordMaxAngle, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.IrradianceCache"), TEXT("DistanceSmoothFactor"), Scene.IrradianceCachingSettings.DistanceSmoothFactor, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.IrradianceCache"), TEXT("AngleSmoothFactor"), Scene.IrradianceCachingSettings.AngleSmoothFactor, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.IrradianceCache"), TEXT("SkyOcclusionSmoothnessReduction"), Scene.IrradianceCachingSettings.SkyOcclusionSmoothnessReduction, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.IrradianceCache"), TEXT("MaxRecordRadius"), Scene.IrradianceCachingSettings.MaxRecordRadius, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.IrradianceCache"), TEXT("CacheTaskSize"), Scene.IrradianceCachingSettings.CacheTaskSize, GLightmassIni));
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.IrradianceCache"), TEXT("InterpolateTaskSize"), Scene.IrradianceCachingSettings.InterpolateTaskSize, GLightmassIni));
	}

	// Modify settings based on the quality level required
	// Preview is assumed to have a scale of 1 for all settings and therefore is not in the ini
	if (QualityLevel != Quality_Preview)
	{
		const TCHAR* QualitySectionNames[Quality_MAX] = {
			TEXT(""), 
			TEXT("DevOptions.StaticLightingMediumQuality"), 
			TEXT("DevOptions.StaticLightingHighQuality"), 
			TEXT("DevOptions.StaticLightingProductionQuality")};

		float NumShadowRaysScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("NumShadowRaysScale"), NumShadowRaysScale, GLightmassIni));
		Scene.ShadowSettings.NumShadowRays = FMath::TruncToInt(Scene.ShadowSettings.NumShadowRays * NumShadowRaysScale);

		float NumPenumbraShadowRaysScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("NumPenumbraShadowRaysScale"), NumPenumbraShadowRaysScale, GLightmassIni));
		Scene.ShadowSettings.NumPenumbraShadowRays = FMath::TruncToInt(Scene.ShadowSettings.NumPenumbraShadowRays * NumPenumbraShadowRaysScale);

		float ApproximateHighResTexelsPerMaxTransitionDistanceScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("ApproximateHighResTexelsPerMaxTransitionDistanceScale"), ApproximateHighResTexelsPerMaxTransitionDistanceScale, GLightmassIni));
		Scene.ShadowSettings.ApproximateHighResTexelsPerMaxTransitionDistance = FMath::TruncToInt(Scene.ShadowSettings.ApproximateHighResTexelsPerMaxTransitionDistance * ApproximateHighResTexelsPerMaxTransitionDistanceScale);

		VERIFYLIGHTMASSINI(GConfig->GetInt(QualitySectionNames[QualityLevel], TEXT("MinDistanceFieldUpsampleFactor"), Scene.ShadowSettings.MinDistanceFieldUpsampleFactor, GLightmassIni));

		float NumHemisphereSamplesScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("NumHemisphereSamplesScale"), NumHemisphereSamplesScale, GLightmassIni));
		Scene.ImportanceTracingSettings.NumHemisphereSamples = FMath::TruncToInt(Scene.ImportanceTracingSettings.NumHemisphereSamples * NumHemisphereSamplesScale);

		float NumImportanceSearchPhotonsScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("NumImportanceSearchPhotonsScale"), NumImportanceSearchPhotonsScale, GLightmassIni));
		Scene.PhotonMappingSettings.NumImportanceSearchPhotons = FMath::TruncToInt(Scene.PhotonMappingSettings.NumImportanceSearchPhotons * NumImportanceSearchPhotonsScale);

		float NumDirectPhotonsScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("NumDirectPhotonsScale"), NumDirectPhotonsScale, GLightmassIni));
		Scene.PhotonMappingSettings.DirectPhotonDensity = Scene.PhotonMappingSettings.DirectPhotonDensity * NumDirectPhotonsScale;
		Scene.PhotonMappingSettings.DirectIrradiancePhotonDensity = Scene.PhotonMappingSettings.DirectIrradiancePhotonDensity * NumDirectPhotonsScale; 

		float DirectPhotonSearchDistanceScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("DirectPhotonSearchDistanceScale"), DirectPhotonSearchDistanceScale, GLightmassIni));
		Scene.PhotonMappingSettings.DirectPhotonSearchDistance = Scene.PhotonMappingSettings.DirectPhotonSearchDistance * DirectPhotonSearchDistanceScale;

		float NumIndirectPhotonPathsScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("NumIndirectPhotonPathsScale"), NumIndirectPhotonPathsScale, GLightmassIni));
		Scene.PhotonMappingSettings.IndirectPhotonPathDensity = Scene.PhotonMappingSettings.IndirectPhotonPathDensity * NumIndirectPhotonPathsScale;

		float NumIndirectPhotonsScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("NumIndirectPhotonsScale"), NumIndirectPhotonsScale, GLightmassIni));
		Scene.PhotonMappingSettings.IndirectPhotonDensity = Scene.PhotonMappingSettings.IndirectPhotonDensity * NumIndirectPhotonsScale;

		float NumIndirectIrradiancePhotonsScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("NumIndirectIrradiancePhotonsScale"), NumIndirectIrradiancePhotonsScale, GLightmassIni));
		Scene.PhotonMappingSettings.IndirectIrradiancePhotonDensity = Scene.PhotonMappingSettings.IndirectIrradiancePhotonDensity * NumIndirectIrradiancePhotonsScale;

		float RecordRadiusScaleScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("RecordRadiusScaleScale"), RecordRadiusScaleScale, GLightmassIni));
		Scene.IrradianceCachingSettings.RecordRadiusScale = Scene.IrradianceCachingSettings.RecordRadiusScale * RecordRadiusScaleScale;

		float InterpolationMaxAngleScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("InterpolationMaxAngleScale"), InterpolationMaxAngleScale, GLightmassIni));
		Scene.IrradianceCachingSettings.InterpolationMaxAngle = Scene.IrradianceCachingSettings.InterpolationMaxAngle * InterpolationMaxAngleScale;

		float IrradianceCacheSmoothFactor;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("IrradianceCacheSmoothFactor"), IrradianceCacheSmoothFactor, GLightmassIni));
		Scene.IrradianceCachingSettings.DistanceSmoothFactor *= IrradianceCacheSmoothFactor;
		Scene.IrradianceCachingSettings.AngleSmoothFactor *= IrradianceCacheSmoothFactor;

		VERIFYLIGHTMASSINI(GConfig->GetInt(QualitySectionNames[QualityLevel], TEXT("NumAdaptiveRefinementLevels"), Scene.ImportanceTracingSettings.NumAdaptiveRefinementLevels, GLightmassIni));

		float AdaptiveBrightnessThresholdScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("AdaptiveBrightnessThresholdScale"), AdaptiveBrightnessThresholdScale, GLightmassIni));
		Scene.ImportanceTracingSettings.AdaptiveBrightnessThreshold = Scene.ImportanceTracingSettings.AdaptiveBrightnessThreshold * AdaptiveBrightnessThresholdScale;

		float AdaptiveFirstBouncePhotonConeAngleScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("AdaptiveFirstBouncePhotonConeAngleScale"), AdaptiveFirstBouncePhotonConeAngleScale, GLightmassIni));
		Scene.ImportanceTracingSettings.AdaptiveFirstBouncePhotonConeAngle = Scene.ImportanceTracingSettings.AdaptiveFirstBouncePhotonConeAngle * AdaptiveFirstBouncePhotonConeAngleScale;

		float AdaptiveSkyVarianceThresholdScale;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(QualitySectionNames[QualityLevel], TEXT("AdaptiveSkyVarianceThresholdScale"), AdaptiveSkyVarianceThresholdScale, GLightmassIni));
		Scene.ImportanceTracingSettings.AdaptiveSkyVarianceThreshold = Scene.ImportanceTracingSettings.AdaptiveSkyVarianceThreshold * AdaptiveSkyVarianceThresholdScale;
	}
}

/** Fills InputData with debug information */
void FLightmassExporter::WriteDebugInput( Lightmass::FDebugLightingInputData& InputData, FGuid& DebugMappingGuid )
{
	InputData.bRelaySolverStats = UE_LOG_ACTIVE(LogLightmassSolver, Log);

	if (IsTexelDebuggingEnabled())
	{
		FindDebugMapping(DebugMappingGuid);
	}
	
	InputData.MappingGuid = DebugMappingGuid;
	InputData.NodeIndex = GCurrentSelectedLightmapSample.NodeIndex;
	InputData.Position = FVector4f(FVector3f(GCurrentSelectedLightmapSample.Position), 0);
	InputData.LocalX = GCurrentSelectedLightmapSample.LocalX;
	InputData.LocalY = GCurrentSelectedLightmapSample.LocalY;
	InputData.MappingSizeX = GCurrentSelectedLightmapSample.MappingSizeX;
	InputData.MappingSizeY = GCurrentSelectedLightmapSample.MappingSizeY;
	FVector4 ViewPosition(0, 0, 0, 0);
	for (FLevelEditorViewportClient* LevelVC : GEditor->GetLevelViewportClients())
	{
		if (LevelVC->IsPerspective())
		{
			ViewPosition = LevelVC->GetViewLocation();
		}
	}
	InputData.CameraPosition = (FVector4f)ViewPosition;
	int32 DebugVisibilityId = INDEX_NONE;
	bool bVisualizePrecomputedVisibility = false;
	VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PrecomputedVisibility"), TEXT("bVisualizePrecomputedVisibility"), bVisualizePrecomputedVisibility, GLightmassIni));
	if (bVisualizePrecomputedVisibility)
	{
		for (FSelectedActorIterator It(World); It; ++It)
		{
			for (UActorComponent* Comp : It->GetComponents())
			{
				if (UPrimitiveComponent* Component = Cast<UPrimitiveComponent>(Comp))
				{
					if (DebugVisibilityId == INDEX_NONE)
					{
						DebugVisibilityId = Component->VisibilityId;
					}
					else if (DebugVisibilityId != Component->VisibilityId)
					{
						UE_LOG(LogLightmassSolver, Warning, TEXT("Not debugging visibility for component %s with vis id %u, as it was not the first component on the selected actor."),
							*Component->GetPathName(), Component->VisibilityId);
					}
				}
			}
		}

		for (int32 LevelIndex= 0; LevelIndex < World->GetNumLevels(); LevelIndex++)
		{
			ULevel* Level = World->GetLevel(LevelIndex);
			for (int32 SurfIdx = 0; SurfIdx < Level->Model->Surfs.Num(); SurfIdx++)
			{
				const FBspSurf& Surf = Level->Model->Surfs[SurfIdx];
				if ((Surf.PolyFlags & PF_Selected) != 0)
				{
					for (int32 NodeIdx = 0; NodeIdx < Level->Model->Nodes.Num(); NodeIdx++)
					{
						const FBspNode& Node = Level->Model->Nodes[NodeIdx];
						if (Node.iSurf == SurfIdx)
						{
							UModelComponent* SomeModelComponent = Level->ModelComponents[Node.ComponentIndex];
							if (DebugVisibilityId == INDEX_NONE)
							{
								DebugVisibilityId = SomeModelComponent->VisibilityId;
							}
							else if (DebugVisibilityId != SomeModelComponent->VisibilityId)
							{
								UE_LOG(LogLightmassSolver, Warning, TEXT("Not debugging visibility for model component %s with vis id %u!"),
									*SomeModelComponent->GetPathName(), SomeModelComponent->VisibilityId);
							}
						}
					}
				}
			}
		}
	}
	InputData.DebugVisibilityId = DebugVisibilityId;
}

void FLightmassExporter::UpdateExportProgress()
{
	CurrentProgress++;

	// Update rarely to reduce time spent redrawing the status, which can be significant
	const int32 ProgressUpdateFrequency = FMath::Max<int32>(TotalProgress / 20,1);
	if (CurrentProgress % ProgressUpdateFrequency == 0)
	{
		GWarn->UpdateProgress(CurrentProgress, TotalProgress);
	}
}

void FLightmassExporter::AddLight(ULightComponentBase* Light)
{
	UDirectionalLightComponent* DirectionalLight = Cast<UDirectionalLightComponent>(Light);
	UPointLightComponent* PointLight = Cast<UPointLightComponent>(Light);
	USpotLightComponent* SpotLight = Cast<USpotLightComponent>(Light);
	URectLightComponent* RectLight = Cast<URectLightComponent>(Light);
	USkyLightComponent* SkyLight = Cast<USkyLightComponent>(Light);

	if( DirectionalLight )
	{
		DirectionalLights.AddUnique(DirectionalLight);
	}
	else if( SpotLight )
	{
		SpotLights.AddUnique(SpotLight);
	}
	else if( PointLight )
	{
		PointLights.AddUnique(PointLight);
	}
	else if( RectLight )
	{
		RectLights.AddUnique(RectLight);
	}
	else if( SkyLight )
	{
		SkyLights.AddUnique(SkyLight);
	}
}

/*-----------------------------------------------------------------------------
	FLightmassProcessor
-----------------------------------------------------------------------------*/

/** 
 * Constructor
 * 
 * @param bInDumpBinaryResults true if it should dump out raw binary lighting data to disk
 */
FLightmassProcessor::FLightmassProcessor(const FStaticLightingSystem& InSystem, bool bInDumpBinaryResults, bool bInOnlyBuildVisibility)
:	Exporter(NULL)
,	Importer(NULL)
,	System(InSystem)
,	Swarm( NSwarm::FSwarmInterface::Get() )
,	bProcessingSuccessful(false)
,	bProcessingFailed(false)
,	bQuitReceived(false)
,	NumCompletedTasks(0)
,	bRunningLightmass(false)
,	bOnlyBuildVisibility( bInOnlyBuildVisibility )
,	bDumpBinaryResults( bInDumpBinaryResults )
,	bImportCompletedMappingsImmediately(false)
,	MappingToProcessIndex(0)
{
	// Since these can be set by the commandline, we need to update them here...
	GLightmassDebugOptions.bDebugMode = GLightmassDebugMode;
	GLightmassDebugOptions.bStatsEnabled = GLightmassStatsMode;

	NSwarm::TLogFlags LogFlags = NSwarm::SWARM_LOG_NONE;
	if (GLightmassDebugOptions.bStatsEnabled)
	{
		LogFlags = NSwarm::TLogFlags(LogFlags | NSwarm::SWARM_LOG_TIMINGS);
	}

	FString OptionsFolder = FPaths::Combine(*FPaths::GameAgnosticSavedDir(), TEXT("Swarm"));
	OptionsFolder = IFileManager::Get().ConvertToAbsolutePathForExternalAppForRead(*OptionsFolder);
	int32 ConnectionHandle = Swarm.OpenConnection( SwarmCallback, this,  LogFlags, *OptionsFolder );
	bSwarmConnectionIsValid = (ConnectionHandle >= 0);
	Exporter = new FLightmassExporter( System.GetLightingContext() );
	check(Exporter);
	Exporter->bSwarmConnectionIsValid = bSwarmConnectionIsValid;

	DeferredMappingsDirectory = InSystem.Options.MappingsDirectory;

	Messages.Add( TEXT("UseErrorColoringButton_Tooltip"), LOCTEXT("UseErrorColoringButton_Tooltip", "Display objects with lighting errors in identifying colors rather than black (Lightmass only).") );
	Messages.Add( TEXT("LightmassError_SupportFP"), LOCTEXT("LightmassError_SupportFP", "Lightmass requires a graphics card with support for floating point rendertargets. Aborting!") );
	Messages.Add( TEXT("LightmassError_MissingImportanceVolume"), LOCTEXT("LightmassError_MissingImportanceVolume", "No importance volume found - lighting build will take a long time and have poor quality.") );
	Messages.Add( TEXT("LightmassError_FailedToAllocateShadowmapChannel"), LOCTEXT("LightmassError_FailedToAllocateShadowmapChannel", "Severe performance loss: Failed to allocate shadowmap channel for stationary light due to overlap - light will fall back to dynamic shadows!") );
	Messages.Add( TEXT("LightmassError_MissingPrecomputedVisibilityVolume"), LOCTEXT("LightmassError_MissingPrecomputedVisibilityVolume", "Level has bPrecomputeVisibility enabled but no Precomputed Visibility Volumes, precomputed visibility will not be effective.") );
	Messages.Add( TEXT("LightmassError_BuildSelected"), LOCTEXT("LightmassError_BuildSelected", "Building selected actors only, lightmap memory and quality will be sub-optimal until the next full rebuild.") );
	Messages.Add( TEXT("LightmassError_BuildSelectedNothingSelected"), LOCTEXT("LightmassError_BuildSelectedNothingSelected", "Building selected actors and BSP only, but no actors or BSP selected!") );
	Messages.Add( TEXT("LightmassError_ObjectWrappedUVs"), LOCTEXT("LightmassError_ObjectWrappedUVs", "Object has wrapping UVs.") );
	Messages.Add( TEXT("LightmassError_ObjectOverlappedUVs"), LOCTEXT("LightmassError_ObjectOverlappedUVs", "Object has overlapping UVs.") );
	Messages.Add( TEXT("LightmassError_EmissiveMeshHighPolyCount"), LOCTEXT("LightmassError_EmissiveMeshHighPolyCount", "Object has a large number of polygons (more than 3000) and will result in a long lighting build.") );
	Messages.Add( TEXT("LightmassError_EmissiveMeshExtremelyHighPolyCount"), LOCTEXT("LightmassError_EmissiveMeshExtremelyHighPolyCount", "Object did not create emissive lights due to excessive polycount (more than 5000).") );
	Messages.Add( TEXT("LightmassError_BadLightMapCoordinateIndex"), LOCTEXT("LightmassError_BadLightMapCoordinateIndex", "StaticMesh has invalid LightMapCoordinateIndex.") );
	Messages.Add( TEXT("LightmassError_ObjectMultipleDominantLights"), LOCTEXT("LightmassError_ObjectMultipleDominantLights", "Object has multiple dominant lights.") );
}

FLightmassProcessor::~FLightmassProcessor()
{
	// Note: the connection must be closed before deleting anything that SwarmCallback accesses
	Swarm.CloseConnection();

	delete Exporter;
	delete Importer;

	for ( TMap<FGuid, FMappingImportHelper*>::TIterator It(ImportedMappings); It; ++It )
	{
		FMappingImportHelper* ImportData = It.Value();
		delete ImportData;
	}
	ImportedMappings.Empty();

	delete DeferredMappings;

	FLandscapeStaticLightingMesh::LandscapeUpscaleHeightDataCache.Empty();
}

/** Retrieve an exporter for the given channel name */
FLightmassExporter* FLightmassProcessor::GetLightmassExporter()
{
	return Exporter;
}

FString FLightmassProcessor::GetMappingFileExtension(const FStaticLightingMapping* InMapping)
{
	// Determine the input file name
	FString FileExtension = TEXT("");
	if (InMapping)
	{
		if (InMapping->IsTextureMapping() == true)
		{
			FileExtension = Lightmass::LM_TEXTUREMAPPING_EXTENSION;
		}
	}

	return FileExtension;
}

int32 FLightmassProcessor_GetMappingFileVersion(const FStaticLightingMapping* InMapping)
{
	// Determine the input file name
	int32 ReturnVersion = 0;
	if (InMapping)
	{
		if (InMapping->IsTextureMapping() == true)
		{
			ReturnVersion = Lightmass::LM_TEXTUREMAPPING_VERSION;
		}
	}
	return ReturnVersion;
}

bool FLightmassProcessor::OpenJob()
{
	// Start the Job
	int32 ErrorCode = Swarm.OpenJob( Exporter->SceneGuid );
	if( ErrorCode < 0 )
	{
		UE_LOG(LogLightmassSolver, Log,  TEXT("Error, OpenJob failed with error code %d"), ErrorCode );
		return false;
	}
	return true;
}

bool FLightmassProcessor::CloseJob()
{
	// All done, end the Job
	int32 ErrorCode = Swarm.CloseJob();
	if( ErrorCode < 0 )
	{
		UE_LOG(LogLightmassSolver, Log,  TEXT("Error, CloseJob failed with error code %d"), ErrorCode );
		return false;
	}
	return true;
}

void FLightmassProcessor::InitiateExport()
{
	FLightmassStatistics::FScopedGather ExportStatScope(Statistics.ExportTime);

	// If the Job started successfully, export the scene
	GWarn->StatusUpdate( 0, 100, LOCTEXT("BeginExportingTheSceneTask", "Exporting the scene...") );
	double StartTime = FPlatformTime::Seconds();

	int32 NumCellDistributionBuckets;
	VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedVisibility"), TEXT("NumCellDistributionBuckets"), NumCellDistributionBuckets, GLightmassIni));
	
	if (System.GetWorld()->GetWorldSettings()->bPrecomputeVisibility)
	{
		for (int32 DistributionBucketIndex = 0; DistributionBucketIndex < NumCellDistributionBuckets; DistributionBucketIndex++)
		{
			Exporter->VisibilityBucketGuids.Add(FGuid::NewGuid());
		}
	}

	if (System.GetWorld()->GetWorldSettings()->LightmassSettings.VolumeLightingMethod == VLM_VolumetricLightmap
		&& !bOnlyBuildVisibility 
		&& !System.Options.bApplyDeferedActorMappingPass )
	{
		Lightmass::FVolumetricLightmapSettings VolumetricLightmapSettings;
		GetLightmassExporter()->SetVolumetricLightmapSettings(VolumetricLightmapSettings);

		const int32 NumTopLevelBricks = VolumetricLightmapSettings.TopLevelGridSize.X * VolumetricLightmapSettings.TopLevelGridSize.Y * VolumetricLightmapSettings.TopLevelGridSize.Z;
		
		int32 TargetNumVolumetricLightmapTasks;
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.VolumetricLightmaps"), TEXT("TargetNumVolumetricLightmapTasks"), TargetNumVolumetricLightmapTasks, GLightmassIni));

		const int32 NumTasksPerTopLevelBrick = FMath::Clamp(TargetNumVolumetricLightmapTasks / NumTopLevelBricks, 1, VolumetricLightmapSettings.BrickSize * VolumetricLightmapSettings.BrickSize * VolumetricLightmapSettings.BrickSize);

		// Generate task guids for top level volumetric lightmap cells
		for (int32 VolumetricLightmapTaskIndex = 0; 
			VolumetricLightmapTaskIndex < NumTopLevelBricks * NumTasksPerTopLevelBrick; 
			VolumetricLightmapTaskIndex++)
		{
			Exporter->VolumetricLightmapTaskGuids.Add(FGuid::NewGuid(), VolumetricLightmapTaskIndex);
		}
	}

	TArray<ULevel*> LevelsToRestore;

	// Hide all other lighting scenarios before we export skylights, which capture the rendered scene
	for (ULevel* Level : System.GetWorld()->GetLevels())
	{
		if (Level->bIsVisible && !System.ShouldOperateOnLevel(Level))
		{
			LevelsToRestore.Add(Level);
			EditorLevelUtils::SetLevelVisibilityTemporarily(Level, false);
		}
	}

	Exporter->WriteToChannel(Statistics, DebugMappingGuid);

	// Restore level state
	for (ULevel* Level : LevelsToRestore)
	{
		EditorLevelUtils::SetLevelVisibilityTemporarily(Level, true);
	}
}

bool FLightmassProcessor::ExecuteAmortizedMaterialExport()
{
	FLightmassStatistics::FScopedGather ExportStatScope(Statistics.ExportTime);

	return Exporter->WriteToMaterialChannel(Statistics);
}

void FLightmassProcessor::IssueStaticShadowDepthMapTask(const ULightComponent* Light, int32 EstimatedCost)
{
	if (Light->HasStaticShadowing() && !Light->HasStaticLighting())
	{
		NSwarm::FTaskSpecification NewTaskSpecification(Light->LightGuid, TEXT("StaticShadowDepthMaps"), NSwarm::JOB_TASK_FLAG_USE_DEFAULTS );
		NewTaskSpecification.Cost = EstimatedCost;
		int32 ErrorCode = Swarm.AddTask( NewTaskSpecification );
		if( ErrorCode >= 0 )
		{
			NumTotalSwarmTasks++;
		}
		else
		{
			UE_LOG(LogLightmassSolver, Warning,  TEXT("Error, AddTask for StaticShadowDepthMaps failed with error code %d"), ErrorCode );
			bProcessingFailed = true;
		}
	}
}

// Helper class for creating a list of paths relative to the engine directory, which can be queried as a list of raw strings.
class FEngineDependencyPaths
{
public:
	FEngineDependencyPaths(std::initializer_list<const TCHAR*> Paths)
	{
		Strings.Reserve(Paths.size());
		for(const TCHAR* Path : Paths)
		{
			Strings.Add(FPaths::EngineDir() / Path);
		}

		RawStrings.Reserve(Strings.Num());
		for(const FString& String : Strings)
		{
			RawStrings.Add(*String);
		}
	}

	const TCHAR** GetArray() const
	{
		return const_cast<const TCHAR**>(RawStrings.GetData());
	}

	int32 Num() const
	{
		return RawStrings.Num();
	}

private:
	TArray<FString> Strings;
	TArray<const TCHAR*> RawStrings;
};

bool FLightmassProcessor::BeginRun()
{
	{
		FLightmassStatistics::FScopedGather ExportStatScope(Statistics.ExportTime);
		bool bGarbageCollectAfterExport = false;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bGarbageCollectAfterExport"), bGarbageCollectAfterExport, GLightmassIni));
		if (bGarbageCollectAfterExport == true)
		{
			CollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS, true);
		}
	}

	double SwarmJobStartTime = FPlatformTime::Seconds();
	VolumeSampleTaskCompleted = 0;
	MeshAreaLightDataTaskCompleted = 0;
	VolumeDistanceFieldTaskCompleted = 0;

	// Check if we can use 64-bit Lightmass.
	bool bUse64bitProcess = false;
	bool bAllow64bitProcess = true;
	VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.StaticLighting"), TEXT("bAllow64bitProcess"), bAllow64bitProcess, GLightmassIni));
	if ( bAllow64bitProcess && FPlatformMisc::Is64bitOperatingSystem() )
	{
		bUse64bitProcess = true;
	}

	// Setup dependencies for 32bit.
	static const FString LightmassExecutable32 = FPaths::EngineDir() / TEXT("Binaries/Win32/UnrealLightmass.exe");
	static const FEngineDependencyPaths RequiredDependencyPaths32 =
	{
		TEXT("Binaries/DotNET/SwarmInterface.dll"),
		TEXT("Binaries/Win32/AgentInterface.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-SwarmInterface.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-ApplicationCore.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-AutoRTFM.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-Core.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-CoreUObject.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-CorePreciseFP.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-DerivedDataCache.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-DevHttp.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-Sockets.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-Zen.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-Projects.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-Json.dll"),
		TEXT("Binaries/Win32/UnrealLightmass-SSL.dll")
		TEXT("Binaries/Win32/UnrealLightmass-BuildSettings.dll")
	};

	// Setup dependencies for 64bit.
#if PLATFORM_WINDOWS
	static const FString LightmassExecutable64 = FPaths::EngineDir() / TEXT("Binaries/Win64/UnrealLightmass.exe");
	static const FEngineDependencyPaths RequiredDependencyPaths64 =
	{
		TEXT("Binaries/DotNET/SwarmInterface.dll"),
		TEXT("Binaries/Win64/AgentInterface.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-SwarmInterface.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-ApplicationCore.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-AutoRTFM.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-Core.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-CoreUObject.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-CorePreciseFP.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-DerivedDataCache.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-DevHttp.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-Sockets.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-Zen.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-Projects.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-Json.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-SSL.dll"),
		TEXT("Binaries/Win64/UnrealLightmass-BuildSettings.dll"),
		TEXT("Binaries/Win64/embree4.dll"),
		TEXT("Binaries/Win64/tbb12.dll"),
		TEXT("Binaries/Win64/tbbmalloc.dll")
	};
#elif PLATFORM_MAC
	static const FString LightmassExecutable64 = FPaths::EngineDir() / TEXT("Binaries/Mac/UnrealLightmass");
	static const FEngineDependencyPaths RequiredDependencyPaths64 =
	{
		TEXT("Binaries/DotNET/Mac/AgentInterface.dll"),
		TEXT("Binaries/Mac/UnrealLightmass-ApplicationCore.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-AutoRTFM.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-Core.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-CoreUObject.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-CorePreciseFP.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-DerivedDataCache.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-DevHttp.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-Sockets.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-Zen.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-Json.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-Projects.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-SSL.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-SwarmInterface.dylib"),
		TEXT("Binaries/Mac/UnrealLightmass-BuildSettings.dylib"),
		TEXT("Binaries/Mac/libembree4.4.3.3.dylib"),
		TEXT("Binaries/Mac/libtbb.12.13.dylib"),
		TEXT("Binaries/Mac/libtbbmalloc.2.13.dylib")
	};
#elif PLATFORM_LINUX
	static const FString LightmassExecutable64 = FPaths::EngineDir() / TEXT("Binaries/Linux/UnrealLightmass");
	static const FEngineDependencyPaths RequiredDependencyPaths64 =
	{
		TEXT("Binaries/DotNET/Linux/AgentInterface.dll"),
		TEXT("Binaries/Linux/libUnrealLightmass-ApplicationCore.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-AutoRTFM.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-Core.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-CoreUObject.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-CorePrecise.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-DerivedDataCache.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-DevHttp.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-Sockets.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-Zen.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-Json.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-Projects.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-SSL.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-SwarmInterface.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-Networking.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-Messaging.so"),
		TEXT("Binaries/Linux/libUnrealLightmass-BuildSettings.so"),
		TEXT("Plugins/Messaging/UdpMessaging/Binaries/Linux/libUnrealLightmass-UdpMessaging.so")
	};
#else // PLATFORM_LINUX
#error "Unknown Lightmass platform"
#endif

	// Set up optional dependencies.  These might not exist in Launcher distributions, for example.
	const FEngineDependencyPaths OptionalDependencyPaths32 =
	{
		TEXT("Binaries/Win32/UnrealLightmass.pdb")
	};

	const FEngineDependencyPaths OptionalDependencyPaths64 =
	{
		TEXT("Binaries/Win64/UnrealLightmass.pdb")
	};

	// Set up the description for the Job
	const TCHAR* DescriptionKeys[] =
	{
		TEXT("MapName"),
		TEXT("GameName"),
		TEXT("QualityLevel")
	};

	// Get the map name
	FString MapNameStr = System.GetWorld()->GetMapName();
	const TCHAR* MapName = MapNameStr.GetCharArray().GetData();
	// Get the game name
	const TCHAR* GameName = FApp::GetProjectName();
	// Get the quality level
	TCHAR QualityLevel[MAX_SPRINTF] = TEXT("");
	FCString::Sprintf( QualityLevel, TEXT("%d"), ( int32 )Exporter->QualityLevel );

	const TCHAR* DescriptionValues[] =
	{
		MapName,
		GameName,
		QualityLevel
	};

	// Create the job - one task per mapping.
	bProcessingSuccessful = false;
	bProcessingFailed = false;
	bQuitReceived = false;
	NumCompletedTasks = 0;
	bRunningLightmass = false;
	
	Statistics.SwarmJobOpenTime += FPlatformTime::Seconds() - SwarmJobStartTime;
	
	UE_LOG(LogLightmassSolver, Log,  TEXT("Swarm launching: %s %s"), bUse64bitProcess ? *LightmassExecutable64 : *LightmassExecutable32, *Exporter->SceneGuid.ToString() );

	SwarmJobStartTime = FPlatformTime::Seconds();

	// If using Debug Mode (off by default), we use a hard-coded job GUID and Lightmass must be executed manually
	// (e.g. through a debugger), using the -debug command line parameter.
	// Lightmass will read all the cached input files and process the whole job locally without notifying
	// Swarm or Unreal that the job is completed. This also means that Lightmass can be executed as many times
	// as required (the input files will still be there in the Swarm cache) and Unreal doesn't need to be
	// running concurrently.
	int32 JobFlags = NSwarm::JOB_FLAG_USE_DEFAULTS;
	if (GLightmassDebugOptions.bDebugMode)
	{
		UE_LOG(LogLightmassSolver, Log,  TEXT("Waiting for UnrealLightmass.exe to be launched manually...") );
		UE_LOG(LogLightmassSolver, Log,  TEXT("Note: This Job will not be distributed") );
		JobFlags |= NSwarm::JOB_FLAG_MANUAL_START;
	}
	else
	{
		// Enable Swarm Job distribution, if requested
		if (GSwarmDebugOptions.bDistributionEnabled)
		{
			UE_LOG(LogLightmassSolver, Log,  TEXT("Swarm will be allowed to distribute this job") );
			JobFlags |= NSwarm::JOB_FLAG_ALLOW_REMOTE;
		}
		else
		{
			UE_LOG(LogLightmassSolver, Log,  TEXT("Swarm will be not be allowed to distribute this job; it will run locally only") );
		}
	}

	// Check to see if swarm should be run minimized (it should by default)
	bool bMinimizeSwarm = true;
	GConfig->GetBool(TEXT("LightingBuildOptions"), TEXT("MinimizeSwarm"), bMinimizeSwarm, GEditorSettingsIni);
	if ( bMinimizeSwarm )
	{
		UE_LOG(LogLightmassSolver, Log,  TEXT("Swarm will be run minimized") );
		JobFlags |= NSwarm::JOB_FLAG_MINIMIZED;
	}

	FString CommandLineParameters = *Exporter->SceneGuid.ToString();
	if (GLightmassDebugOptions.bStatsEnabled)
	{
		CommandLineParameters += TEXT(" -stats");
	}

	NSwarm::FJobSpecification JobSpecification32, JobSpecification64;
	if ( !bUse64bitProcess )
	{
		JobSpecification32 = NSwarm::FJobSpecification( *LightmassExecutable32, *CommandLineParameters, ( NSwarm::TJobTaskFlags )JobFlags );
		JobSpecification32.AddDependencies( RequiredDependencyPaths32.GetArray(), RequiredDependencyPaths32.Num(), OptionalDependencyPaths32.GetArray(), OptionalDependencyPaths32.Num() );
		JobSpecification32.AddDescription( DescriptionKeys, DescriptionValues, UE_ARRAY_COUNT(DescriptionKeys) );
	}
	else
	{
		JobSpecification64 = NSwarm::FJobSpecification( *LightmassExecutable64, *CommandLineParameters, ( NSwarm::TJobTaskFlags )JobFlags );
		JobSpecification64.AddDependencies( RequiredDependencyPaths64.GetArray(), RequiredDependencyPaths64.Num(), OptionalDependencyPaths64.GetArray(), OptionalDependencyPaths64.Num() );
		JobSpecification64.AddDescription( DescriptionKeys, DescriptionValues, UE_ARRAY_COUNT(DescriptionKeys) );
	}
	int32 ErrorCode = Swarm.BeginJobSpecification( JobSpecification32, JobSpecification64 );
	if( ErrorCode < 0 )
	{
		UE_LOG(LogLightmassSolver, Log,  TEXT("Error, BeginJobSpecification failed with error code %d"), ErrorCode );
		bProcessingFailed = true;
	}

	// Count the number of tasks given to Swarm
	NumTotalSwarmTasks = 0;

	if (System.GetWorld()->GetWorldSettings()->bPrecomputeVisibility)
	{
		for (int32 TaskIndex = 0; TaskIndex < Exporter->VisibilityBucketGuids.Num(); TaskIndex++)
		{
			NSwarm::FTaskSpecification NewTaskSpecification( Exporter->VisibilityBucketGuids[TaskIndex], TEXT("PrecomputedVisibility"), NSwarm::JOB_TASK_FLAG_USE_DEFAULTS );
			//@todo - accurately estimate cost
			NewTaskSpecification.Cost = 10000;
			ErrorCode = Swarm.AddTask( NewTaskSpecification );
			if( ErrorCode >= 0 )
			{
				NumTotalSwarmTasks++;
			}
			else
			{
				UE_LOG(LogLightmassSolver, Log,  TEXT("Error, AddTask failed with error code %d"), ErrorCode );
			}
		}
	}

	if (!bOnlyBuildVisibility)
	{
		const EVolumeLightingMethod VolumeLightingMethod = System.GetWorld()->GetWorldSettings()->LightmassSettings.VolumeLightingMethod;

		if (VolumeLightingMethod == VLM_VolumetricLightmap)
		{
			for (TMap<FGuid, int32>::TIterator It(Exporter->VolumetricLightmapTaskGuids); It; ++It )
			{
				NSwarm::FTaskSpecification NewTaskSpecification(It.Key(), TEXT("VolumetricLightmap"), NSwarm::JOB_TASK_FLAG_USE_DEFAULTS );
				//@todo - accurately estimate cost
				NewTaskSpecification.Cost = 10000;
				ErrorCode = Swarm.AddTask( NewTaskSpecification );

				UE_LOG(LogLightmassSolver, Verbose, TEXT("AddTask VLM %s"), *It.Key().ToString() );

				if( ErrorCode >= 0 )
				{
					NumTotalSwarmTasks++;
				}
				else
				{
					UE_LOG(LogLightmassSolver, Warning,  TEXT("Error, AddTask failed with error code %d"), ErrorCode );
					bProcessingFailed = true;
				}
			}
		}
		else
		{
			check(VolumeLightingMethod == VLM_SparseVolumeLightingSamples);
			NSwarm::FTaskSpecification NewTaskSpecification( Lightmass::PrecomputedVolumeLightingGuid, TEXT("VolumeSamples"), NSwarm::JOB_TASK_FLAG_USE_DEFAULTS );
			//@todo - accurately estimate cost
			// Changed estimated cost: this should be the maximum cost, because it became really big if there are WORLD_MAX size light-mapping
			NewTaskSpecification.Cost = INT_MAX;
			ErrorCode = Swarm.AddTask( NewTaskSpecification );
			if( ErrorCode >= 0 )
			{
				NumTotalSwarmTasks++;
			}
			else
			{
				UE_LOG(LogLightmassSolver, Warning,  TEXT("Error, AddTask failed with error code %d"), ErrorCode );
				bProcessingFailed = true;
			}
		}

		{
			NSwarm::FTaskSpecification NewTaskSpecification( Lightmass::MeshAreaLightDataGuid, TEXT("MeshAreaLightData"), NSwarm::JOB_TASK_FLAG_USE_DEFAULTS );
			NewTaskSpecification.Cost = 1000;
			ErrorCode = Swarm.AddTask( NewTaskSpecification );
			UE_LOG(LogLightmassSolver, Verbose, TEXT("AddTask MeshAreasLights %s"), *Lightmass::MeshAreaLightDataGuid.ToString());

			if( ErrorCode >= 0 )
			{
				NumTotalSwarmTasks++;
			}
			else
			{
				UE_LOG(LogLightmassSolver, Log,  TEXT("Error, AddTask failed with error code %d"), ErrorCode );
				bProcessingFailed = true;
			}
		}

		{
			for (int32 LightIndex = 0; LightIndex < Exporter->DirectionalLights.Num(); LightIndex++)
			{
				const ULightComponent* Light = Exporter->DirectionalLights[LightIndex];
				IssueStaticShadowDepthMapTask(Light, INT_MAX);
			}
			
			for (int32 LightIndex = 0; LightIndex < Exporter->SpotLights.Num(); LightIndex++)
			{
				const ULightComponent* Light = Exporter->SpotLights[LightIndex];
				IssueStaticShadowDepthMapTask(Light, 10000);
			}

			for (int32 LightIndex = 0; LightIndex < Exporter->PointLights.Num(); LightIndex++)
			{
				const ULightComponent* Light = Exporter->PointLights[LightIndex];
				IssueStaticShadowDepthMapTask(Light, 10000);
			}

			for (int32 LightIndex = 0; LightIndex < Exporter->RectLights.Num(); LightIndex++)
			{
				const ULightComponent* Light = Exporter->RectLights[LightIndex];
				IssueStaticShadowDepthMapTask(Light, 10000);
			}
		}

		// Add BSP mapping tasks.
		for( int32 MappingIdx=0; (ErrorCode >= 0) && MappingIdx < Exporter->BSPSurfaceMappings.Num() && !GEditor->GetMapBuildCancelled(); MappingIdx++ )
		{
			FBSPSurfaceStaticLighting* BSPMapping = Exporter->BSPSurfaceMappings[MappingIdx];
			if (BSPMapping->bProcessMapping == true)
			{
				PendingBSPMappings.Add(BSPMapping->GetLightingGuid(), BSPMapping);

				NSwarm::FTaskSpecification NewTaskSpecification( BSPMapping->GetLightingGuid(), TEXT("BSPMapping"), NSwarm::JOB_TASK_FLAG_USE_DEFAULTS );
				NewTaskSpecification.Cost = BSPMapping->GetTexelCount();
				ErrorCode = Swarm.AddTask( NewTaskSpecification );
				if( ErrorCode >= 0 )
				{
					NumTotalSwarmTasks++;
				}
				else
				{
					UE_LOG(LogLightmassSolver, Log,  TEXT("Error, AddTask failed with error code %d"), ErrorCode );
				}
			}
		}

		// Add static mesh texture mappings tasks.
		for( int32 MappingIdx=0; (ErrorCode >= 0) && MappingIdx < Exporter->StaticMeshTextureMappings.Num() && !GEditor->GetMapBuildCancelled(); MappingIdx++ )
		{
			FStaticMeshStaticLightingTextureMapping* SMTextureMapping = Exporter->StaticMeshTextureMappings[MappingIdx];
			if (SMTextureMapping->bProcessMapping == true)
			{
				PendingTextureMappings.Add(SMTextureMapping->GetLightingGuid(), SMTextureMapping);

				NSwarm::FTaskSpecification NewTaskSpecification( SMTextureMapping->GetLightingGuid(), TEXT("SMTextureMapping"), NSwarm::JOB_TASK_FLAG_USE_DEFAULTS );
				NewTaskSpecification.Cost = SMTextureMapping->GetTexelCount();
				ErrorCode = Swarm.AddTask( NewTaskSpecification );

				UE_LOG(LogLightmassSolver, Verbose, TEXT("AddTask Mapping %s"), *SMTextureMapping->GetLightingGuid().ToString());

				if( ErrorCode >= 0 )
				{
					NumTotalSwarmTasks++;
				}
				else
				{
					UE_LOG(LogLightmassSolver, Log,  TEXT("Error, AddTask failed with error code %d"), ErrorCode );
				}
			}
		}

		// Add Landscape mapping tasks.
		for( int32 MappingIdx=0; (ErrorCode >= 0) && MappingIdx < Exporter->LandscapeTextureMappings.Num() && !GEditor->GetMapBuildCancelled(); MappingIdx++ )
		{
			FLandscapeStaticLightingTextureMapping* LandscapeMapping = Exporter->LandscapeTextureMappings[MappingIdx];
			if (LandscapeMapping->bProcessMapping == true)
			{
				PendingLandscapeMappings.Add(LandscapeMapping->GetLightingGuid(), LandscapeMapping);

				NSwarm::FTaskSpecification NewTaskSpecification( LandscapeMapping->GetLightingGuid(), TEXT("LandscapeMapping"), NSwarm::JOB_TASK_FLAG_USE_DEFAULTS );
				NewTaskSpecification.Cost = LandscapeMapping->GetTexelCount();
				ErrorCode = Swarm.AddTask( NewTaskSpecification );

				UE_LOG(LogLightmassSolver, Verbose, TEXT("AddTask Landscape Mapping %s"), *LandscapeMapping->GetLightingGuid().ToString());

				if( ErrorCode >= 0 )
				{
					NumTotalSwarmTasks++;
				}
				else
				{
					UE_LOG(LogLightmassSolver, Log,  TEXT("Error, AddTask failed with error code %d"), ErrorCode );
				}
			}
		}
	}

	int32 EndJobErrorCode = Swarm.EndJobSpecification();
	if( EndJobErrorCode < 0 )
	{
		UE_LOG(LogLightmassSolver, Log,  TEXT("Error, EndJobSpecification failed with error code %d"), ErrorCode );
	}

	if ( ErrorCode < 0 || EndJobErrorCode < 0 )
	{
		bProcessingFailed = true;
	}

	int32 NumTotalTasks = NumTotalSwarmTasks;
	
	// In deterministic mode, we import and process the mappings after Lightmass is done, so we have twice the steps.
	NumTotalTasks *= 2;

	GWarn->StatusUpdate( NumCompletedTasks, NumTotalTasks, LOCTEXT("BeginRunningLightmassTask", "Running Lightmass...") );

	Statistics.SwarmJobOpenTime += FPlatformTime::Seconds() - SwarmJobStartTime;
	
	LightmassStartTime = FPlatformTime::Seconds();

#if USE_LOCAL_SWARM_INTERFACE
	// @todo Mac: add proper progress reporting from UnrealLightmass
	bProcessingSuccessful = true;
#endif

	return !bProcessingFailed;
}

int32 FLightmassProcessor::GetAsyncPercentDone() const
{
	return NumCompletedTasks * 100 / NumTotalSwarmTasks;
}

float FLightmassProcessor::GetAmortizedExportPercentDone() const
{
	return Exporter->GetAmortizedExportPercentDone();
}

bool FLightmassProcessor::Update()
{
	bool bIsFinished = false;
	if ( !bQuitReceived && !bProcessingFailed && !GEditor->GetMapBuildCancelled() )
	{
		bool bAllTaskAreComplete = (FPlatformAtomics::AtomicRead(&NumCompletedTasks) == NumTotalSwarmTasks ? true : false);

#if USE_LOCAL_SWARM_INTERFACE
		if (IsRunningCommandlet())
		{
			FTaskGraphInterface::Get().ProcessThreadUntilIdle(ENamedThreads::GameThread);
		}
#endif

		GLog->Flush();

		bIsFinished = bAllTaskAreComplete && bProcessingSuccessful;

		if (bIsFinished)
		{
			Statistics.LightmassTime += FPlatformTime::Seconds() - LightmassStartTime;
		}
	}
	else
	{
		bIsFinished = true;
	}

	ProcessAlertMessages();

#if USE_LOCAL_SWARM_INTERFACE
	int32 Status = 0;
	const bool bIsLightmassRunning = Swarm.IsJobProcessRunning(&Status);
	if (!bIsLightmassRunning)
	{
		bIsFinished = true;
		bProcessingFailed = Status != 0;
		bProcessingSuccessful = !bProcessingFailed;
	}
#endif

	return bIsFinished;
}

void FLightmassProcessor::ImportDeferredMappings()
{
	TArray<FString> Files;
	IFileManager::Get().FindFiles(Files, *DeferredMappingsDirectory, TEXT(".lm"));

	DeferredMappings = new FDeferredMappingsBundle;
	
	// load the mappings
	for(const FString& FileName : Files)
	{
		TArray<uint8> FileData;
		int32 BaseMappingIndex  = DeferredMappings->Mappings.Num();
		FString FullFileName = FString::Printf(TEXT("%s\\%s"), *DeferredMappingsDirectory, *FileName);

		if (FFileHelper::LoadFileToArray(FileData, *FullFileName))
		{
			FObjectMemoryReader Reader(FileData);
		
			FDeferredMappingsBundle Bundle;
			Bundle.Serialize(Reader, false);

			for (FLightmassProcessor::FTextureMappingImportHelper& Mapping : Bundle.Mappings)
			{
				// Those mapping guid are just numbered 0 to n, so we rebase them to be unique in the combined mappings
				Mapping.MappingGuid.D += BaseMappingIndex;
			}

			// transfer all bundle mappings
			DeferredMappings->Mappings.Append(Bundle.Mappings);
		}
		else
		{
			UE_LOG(LogLightmassSolver, Warning, TEXT("Error, couldn't import deferred mapping %s"), *FullFileName);
			bProcessingFailed = true;
		}
	}

	DeferredMappings->MapHelpers();

	for (FLightmassProcessor::FTextureMappingImportHelper& Mapping : DeferredMappings->Mappings)
	{
		ImportedMappings.Add(Mapping.MappingGuid, &Mapping);
	}	
}

void FLightmassProcessor::ClearImportedDeferredMappings()
{
	if (DeferredMappings)
	{
		for (FLightmassProcessor::FTextureMappingImportHelper& Mapping : DeferredMappings->Mappings)
		{
			ImportedMappings.Remove(Mapping.MappingGuid);
		}
	}
}


void FLightmassProcessor::ExportDeferredMappings()
{
	if (DeferredMappings && !System.Options.bApplyDeferedActorMappingPass)
	{		
		FGuid BundleGuid = FGuid::NewGuid();

		FString FileName = FString::Printf(TEXT("Mappings_%s.lm"), *BundleGuid.ToString());

		TArray<uint8> FileData;
		FObjectMemoryWriter Writer(FileData);

		DeferredMappings->Serialize(Writer, false);

		FString FullFileName = FString::Printf(TEXT("%s\\%s"), *DeferredMappingsDirectory, *FileName);

		if (!FFileHelper::SaveArrayToFile(FileData, *FullFileName))
		{
			UE_LOG(LogLightmassSolver, Warning, TEXT("Error, couldn't export deferred mapping %s"), *FullFileName);
			bProcessingFailed = true;
		}
	}
}

bool FLightmassProcessor::IsDeferredMapping(const FGuid& Guid)
{
	if (const FStaticLightingMapping* Mapping = Exporter->FindMappingByGuid(Guid))
	{
		return Mapping->IsDeferred();
	}
	return false;
}

void FLightmassProcessor::DeferMapping(FTextureMappingImportHelper* ImportHelper)
{
	if (!DeferredMappings)
	{
		DeferredMappings = new FDeferredMappingsBundle();
	}

 	DeferredMappings->Mappings.Add(*ImportHelper);
	DeferredMappings->OwnerToMapping.Add(ImportHelper->OwnerGuid, ImportHelper->MappingGuid);
}

bool FLightmassProcessor::CompleteRun()
{
	bRunningLightmass = false;
	
	double ImportStartTime = FPlatformTime::Seconds();
	double OriginalApplyTime = Statistics.ApplyTimeInProcessing;

	if ( !bProcessingFailed && !GEditor->GetMapBuildCancelled() )
	{
		ImportVolumeSamples();

		if (Exporter->VolumetricLightmapTaskGuids.Num() > 0)
		{
			ImportVolumetricLightmap();
		}
		
		ImportPrecomputedVisibility();
		ImportMeshAreaLightData();
		ImportVolumeDistanceFieldData();

		if (bImportCompletedMappingsImmediately)
		{
			if (System.Options.bApplyDeferedActorMappingPass)
			{
				ImportDeferredMappings();
			}

			// Import any outstanding completed mappings.
			ImportMappings(false);

			{
				// Detach all components
				// This must be done globally because different mappings will
				FGlobalComponentRecreateRenderStateContext ReregisterContext;

				// Block until the RT processes the unregister before modifying variables that it may need to access
				FlushRenderingCommands();

				ProcessAvailableMappings();
			}

			// Export mapping which we'll not process on this run (this will remove then from available mappings)
			ExportDeferredMappings();
		}

		ApplyPrecomputedVisibility();
		ProcessAlertMessages();
	}
	CompletedMappingTasks.Clear();
	CompletedVisibilityTasks.Clear();
	CompletedVolumetricLightmapTasks.Clear();

	ClearImportedDeferredMappings();

	double ApplyTimeDelta = Statistics.ApplyTimeInProcessing - OriginalApplyTime;
	Statistics.ImportTimeInProcessing += FPlatformTime::Seconds() - ImportStartTime - ApplyTimeDelta;

	return bProcessingSuccessful;
}

bool FLightmassProcessor::IsProcessingCompletedSuccessfully() const
{
	return bProcessingSuccessful &&
		!bQuitReceived && !bProcessingFailed && !GEditor->GetMapBuildCancelled();
}

/**
 * Import all mappings that have been completed so far.
 *	@param	bProcessImmediately		If true, immediately process the mapping
 *									If false, store it off for later processing
 */
void FLightmassProcessor::ImportMappings(bool bProcessImmediately)
{
	// This will return a list of all the completed Guids
	TList<FGuid>* Element = CompletedMappingTasks.ExtractAll();

	// Reverse the list, so we have the mappings in the same order that they came in
	{
		TList<FGuid>* PrevElement = NULL;
		TList<FGuid>* NextElement = NULL;
		while (Element)
		{
			NextElement = Element->Next;
			Element->Next = PrevElement;
			PrevElement = Element;
			Element = NextElement;
		}
		// Assign the new head of the list
		Element = PrevElement;
	}
	
	while ( Element )
	{
		TList<FGuid>* NextElement = Element->Next;
		ImportMapping( Element->Element, bProcessImmediately );
		delete Element;
		Element = NextElement;
	}
}

static_assert(LM_NUM_SH_COEFFICIENTS == NUM_INDIRECT_LIGHTING_SH_COEFFICIENTS, "Lightmass SH generation must match engine SH expectations.");

/** Imports volume lighting samples from Lightmass and adds them to the appropriate levels. */
void FLightmassProcessor::ImportVolumeSamples()
{
	if (VolumeSampleTaskCompleted > 0)
	{
		{
			static_assert(sizeof(FDebugVolumeLightingSample) == sizeof(Lightmass::FDebugVolumeLightingSample), "Debug type sizes must match.");
			const FString ChannelName = Lightmass::CreateChannelName(Lightmass::VolumeLightingDebugOutputGuid, Lightmass::LM_VOLUMEDEBUGOUTPUT_VERSION, Lightmass::LM_VOLUMEDEBUGOUTPUT_EXTENSION);
			const int32 Channel = Swarm.OpenChannel( *ChannelName, LM_VOLUMEDEBUGOUTPUT_CHANNEL_FLAGS );
			if (Channel >= 0)
			{
				ReadArray(Channel, GDebugStaticLightingInfo.VolumeLightingSamples);
				Swarm.CloseChannel(Channel);
			}
		}

		const FString ChannelName = Lightmass::CreateChannelName(Lightmass::PrecomputedVolumeLightingGuid, Lightmass::LM_VOLUMESAMPLES_VERSION, Lightmass::LM_VOLUMESAMPLES_EXTENSION);
		const int32 Channel = Swarm.OpenChannel( *ChannelName, LM_VOLUMESAMPLES_CHANNEL_FLAGS );
		if (Channel >= 0)
		{
			FVector4f UnusedVolumeCenter;
			Swarm.ReadChannel(Channel, &UnusedVolumeCenter, sizeof(UnusedVolumeCenter));
			FVector4f UnusedVolumeExtent;
			Swarm.ReadChannel(Channel, &UnusedVolumeExtent, sizeof(UnusedVolumeExtent));

			int32 NumStreamLevels = System.GetWorld()->GetStreamingLevels().Num();
			int32 NumVolumeSampleArrays;
			Swarm.ReadChannel(Channel, &NumVolumeSampleArrays, sizeof(NumVolumeSampleArrays));
			for (int32 ArrayIndex = 0; ArrayIndex < NumVolumeSampleArrays; ArrayIndex++)
			{
				FGuid LevelGuid;
				Swarm.ReadChannel(Channel, &LevelGuid, sizeof(LevelGuid));
				TArray<Lightmass::FVolumeLightingSampleData> VolumeSamples;
				ReadArray(Channel, VolumeSamples);
				ULevel* CurrentLevel = System.LightingContext.GetLevelForGuid(LevelGuid).Get();

				// Only build precomputed light for visible streamed levels
				if (CurrentLevel && CurrentLevel->bIsVisible)
				{
					UMapBuildDataRegistry* CurrentRegistry = System.LightingContext.GetOrCreateRegistryForLevel(CurrentLevel);
					FPrecomputedLightVolumeData& CurrentLevelData = CurrentRegistry->AllocateLevelPrecomputedLightVolumeBuildData(CurrentLevel->LevelBuildDataId);

					FBox3f LevelVolumeBounds(ForceInit);

					for (int32 SampleIndex = 0; SampleIndex < VolumeSamples.Num(); SampleIndex++)
					{
						const Lightmass::FVolumeLightingSampleData& CurrentSample = VolumeSamples[SampleIndex];
						FVector4f SampleMin = CurrentSample.PositionAndRadius - FVector3f(CurrentSample.PositionAndRadius.W);
						FVector4f SampleMax = CurrentSample.PositionAndRadius + FVector3f(CurrentSample.PositionAndRadius.W);
						LevelVolumeBounds += FBox3f(SampleMin, SampleMax);
					}

					CurrentLevelData.Initialize(FBox(LevelVolumeBounds));

					for (int32 SampleIndex = 0; SampleIndex < VolumeSamples.Num(); SampleIndex++)
					{
						const Lightmass::FVolumeLightingSampleData& CurrentSample = VolumeSamples[SampleIndex];
						FVolumeLightingSample NewHighQualitySample;
						NewHighQualitySample.Position = FVector4f(CurrentSample.PositionAndRadius);
						NewHighQualitySample.Radius = CurrentSample.PositionAndRadius.W;
						NewHighQualitySample.SetPackedSkyBentNormal(FVector3d(CurrentSample.SkyBentNormal)); 
						NewHighQualitySample.DirectionalLightShadowing = CurrentSample.DirectionalLightShadowing;

						for (int32 CoefficientIndex = 0; CoefficientIndex < NUM_INDIRECT_LIGHTING_SH_COEFFICIENTS; CoefficientIndex++)
						{
							NewHighQualitySample.Lighting.R.V[CoefficientIndex] = CurrentSample.HighQualityCoefficients[CoefficientIndex][0];
							NewHighQualitySample.Lighting.G.V[CoefficientIndex] = CurrentSample.HighQualityCoefficients[CoefficientIndex][1];
							NewHighQualitySample.Lighting.B.V[CoefficientIndex] = CurrentSample.HighQualityCoefficients[CoefficientIndex][2];
						}							

						FVolumeLightingSample NewLowQualitySample;
						NewLowQualitySample.Position = FVector4f(CurrentSample.PositionAndRadius);
						NewLowQualitySample.Radius = CurrentSample.PositionAndRadius.W;
						NewLowQualitySample.DirectionalLightShadowing = CurrentSample.DirectionalLightShadowing;
						NewLowQualitySample.SetPackedSkyBentNormal(FVector3d(CurrentSample.SkyBentNormal)); 

						for (int32 CoefficientIndex = 0; CoefficientIndex < NUM_INDIRECT_LIGHTING_SH_COEFFICIENTS; CoefficientIndex++)
						{
							NewLowQualitySample.Lighting.R.V[CoefficientIndex] = CurrentSample.LowQualityCoefficients[CoefficientIndex][0];
							NewLowQualitySample.Lighting.G.V[CoefficientIndex] = CurrentSample.LowQualityCoefficients[CoefficientIndex][1];
							NewLowQualitySample.Lighting.B.V[CoefficientIndex] = CurrentSample.LowQualityCoefficients[CoefficientIndex][2];
						}							

						CurrentLevelData.AddHighQualityLightingSample(NewHighQualitySample);
						CurrentLevelData.AddLowQualityLightingSample(NewLowQualitySample);
					}

					CurrentLevelData.FinalizeSamples();
				}
			}

			Swarm.CloseChannel(Channel);
		}
		else
		{
			UE_LOG(LogLightmassSolver, Log,  TEXT("Error, OpenChannel failed to open %s with error code %d"), *ChannelName, Channel );
		}
		FPlatformAtomics::InterlockedExchange(&VolumeSampleTaskCompleted, 0);
	}
}

/** Imports precomputed visibility */
void FLightmassProcessor::ImportPrecomputedVisibility()
{
	TList<FGuid>* Element = CompletedVisibilityTasks.ExtractAll();

	// Reverse the list, so we have the tasks in the same order that they came in
	{
		TList<FGuid>* PrevElement = NULL;
		TList<FGuid>* NextElement = NULL;
		while (Element)
		{
			NextElement = Element->Next;
			Element->Next = PrevElement;
			PrevElement = Element;
			Element = NextElement;
		}
		// Assign the new head of the list
		Element = PrevElement;
	}
	
	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_PRECOMPUTEDVISIBILITY_VERSION, Lightmass::LM_PRECOMPUTEDVISIBILITY_EXTENSION);
		const int32 Channel = Swarm.OpenChannel( *ChannelName, LM_PRECOMPUTEDVISIBILITY_CHANNEL_FLAGS );
		if (Channel >= 0)
		{
			// Find the index of this visibility task in VisibilityBucketGuids
			const int32 ArrayIndex = Exporter->VisibilityBucketGuids.Find(Element->Element);
			check(ArrayIndex >= 0);

			if (CompletedPrecomputedVisibilityCells.Num() == 0)
			{
				CompletedPrecomputedVisibilityCells.AddZeroed(Exporter->VisibilityBucketGuids.Num());
			}
			
			int32 NumCells = 0;
			Swarm.ReadChannel(Channel, &NumCells, sizeof(NumCells));

			for (int32 CellIndex = 0; CellIndex < NumCells; CellIndex++)
			{
				FBox3f Bounds;
				Swarm.ReadChannel(Channel, &Bounds, sizeof(Bounds));

				// Use the same index for this task guid as it has in VisibilityBucketGuids, so that visibility cells are processed in a deterministic order
				CompletedPrecomputedVisibilityCells[ArrayIndex].AddZeroed();
				FUncompressedPrecomputedVisibilityCell& CurrentCell = CompletedPrecomputedVisibilityCells[ArrayIndex].Last();
				CurrentCell.Bounds = FBox(Bounds);
				ReadArray(Channel, CurrentCell.VisibilityData);
			}

			TArray<FDebugStaticLightingRay> DebugRays;
			ReadArray(Channel, DebugRays);
			GDebugStaticLightingInfo.PrecomputedVisibilityRays.Append(DebugRays);

			Swarm.CloseChannel(Channel);
		}
		else
		{
			UE_LOG(LogLightmassSolver, Log,  TEXT("Error, OpenChannel failed to open %s with error code %d"), *ChannelName, Channel );
		}

		delete Element;
		Element = NextElement;
	}
}

static bool IsMeshVisible(const TArray<uint8>& VisibilityData, int32 MeshId)
{
	return (VisibilityData[MeshId / 8] & 1 << (MeshId % 8)) != 0;
}

static int32 AccumulateVisibility(const TArray<uint8>& OtherCellData, TArray<uint8>& CellData)
{
	int32 NumAdded = 0;

	checkSlow(OtherCellData.Num() == CellData.Num());
	for (int32 i = 0; i < OtherCellData.Num(); i++)
	{
		if (OtherCellData[i] != 0)
		{
			for (int32 BitIndex = 0; BitIndex < 8; BitIndex++)
			{
				NumAdded += IsMeshVisible(OtherCellData, i * 8 + BitIndex) && !IsMeshVisible(CellData, i * 8 + BitIndex) ? 1 : 0;
			}
		}

		CellData[i] |= OtherCellData[i];
	}
	return NumAdded;
}

struct FPrecomputedVisibilitySortGridCell
{
	TArray<FUncompressedPrecomputedVisibilityCell, TInlineAllocator<2>> Cells;
};

void SpreadVisibilityCell(
	float CellSize, 
	float PlayAreaHeight,
	const FUncompressedPrecomputedVisibilityCell& OtherCell,
	FUncompressedPrecomputedVisibilityCell& VisibilityCell,
	int32& QueriesVisibleFromSpreadingNeighbors)
{
	// Determine whether the cell is a world space neighbor
	if (!(OtherCell.Bounds.Min == VisibilityCell.Bounds.Min && OtherCell.Bounds.Max == VisibilityCell.Bounds.Max)
		&& FMath::Abs(VisibilityCell.Bounds.Min.X - OtherCell.Bounds.Min.X) < CellSize + KINDA_SMALL_NUMBER
		&& FMath::Abs(VisibilityCell.Bounds.Min.Y - OtherCell.Bounds.Min.Y) < CellSize + KINDA_SMALL_NUMBER
		// Don't spread from cells below, they're probably below the ground and see too much
		&& OtherCell.Bounds.Min.Z - VisibilityCell.Bounds.Min.Z > -PlayAreaHeight * 0.5f
		// Only spread from one cell above
		&& OtherCell.Bounds.Min.Z - VisibilityCell.Bounds.Min.Z < PlayAreaHeight * 1.5f)
	{
		// Combine the neighbor's visibility with the current cell's visibility
		// This reduces visibility errors at the cost of less effective culling
		QueriesVisibleFromSpreadingNeighbors += AccumulateVisibility(OtherCell.VisibilityData, VisibilityCell.VisibilityData);
	}
}

void FLightmassProcessor::ApplyPrecomputedVisibility()
{
	TArray<FUncompressedPrecomputedVisibilityCell> CombinedPrecomputedVisibilityCells;
	for (int32 ArrayIndex = 0; ArrayIndex < CompletedPrecomputedVisibilityCells.Num(); ArrayIndex++)
	{
		CombinedPrecomputedVisibilityCells.Append(CompletedPrecomputedVisibilityCells[ArrayIndex]);
	}
	CompletedPrecomputedVisibilityCells.Empty();

	if (CombinedPrecomputedVisibilityCells.Num() > 0)
	{
		const double StartTime = FPlatformTime::Seconds();
		int32 VisibilitySpreadingIterations;

		const TCHAR* AggressivenessSectionNames[VIS_Max] = {
			TEXT("DevOptions.PrecomputedVisibility"), 
			TEXT("DevOptions.PrecomputedVisibilityModeratelyAggressive"), 
			TEXT("DevOptions.PrecomputedVisibilityMostAggressive")};
		const TCHAR* ActiveSection = AggressivenessSectionNames[FMath::Clamp((int32)System.GetWorld()->GetWorldSettings()->VisibilityAggressiveness, 0, VIS_Max - 1)];
		VERIFYLIGHTMASSINI(GConfig->GetInt(ActiveSection, TEXT("VisibilitySpreadingIterations"), VisibilitySpreadingIterations, GLightmassIni));
		bool bCompressVisibilityData;
		VERIFYLIGHTMASSINI(GConfig->GetBool(TEXT("DevOptions.PrecomputedVisibility"), TEXT("bCompressVisibilityData"), bCompressVisibilityData, GLightmassIni));
		const float CellSize = System.GetWorld()->GetWorldSettings()->VisibilityCellSize;
		float PlayAreaHeight = 0;
		VERIFYLIGHTMASSINI(GConfig->GetFloat(TEXT("DevOptions.PrecomputedVisibility"), TEXT("PlayAreaHeight"), PlayAreaHeight, GLightmassIni));
		int32 CellBucketSize = 0;
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedVisibility"), TEXT("CellRenderingBucketSize"), CellBucketSize, GLightmassIni));
		int32 NumCellBuckets = 0;
		VERIFYLIGHTMASSINI(GConfig->GetInt(TEXT("DevOptions.PrecomputedVisibility"), TEXT("NumCellRenderingBuckets"), NumCellBuckets, GLightmassIni));

		int32 TotalNumQueries = 0;
		int32 QueriesVisibleFromSpreadingNeighbors = 0;

		for (int32 IterationIndex = 0; IterationIndex < VisibilitySpreadingIterations; IterationIndex++)
		{
			FBox AllCellsBounds(ForceInit);

			for (int32 CellIndex = 0; CellIndex < CombinedPrecomputedVisibilityCells.Num(); CellIndex++)
			{
				AllCellsBounds += CombinedPrecomputedVisibilityCells[CellIndex].Bounds;
			}

			int32 GridSizeX = FMath::TruncToInt(AllCellsBounds.GetSize().X / CellSize + .5f);
			int32 GridSizeY = FMath::TruncToInt(AllCellsBounds.GetSize().Y / CellSize + .5f);

			const int32 GridSizeMax = 10000;

			if (GridSizeX < GridSizeMax && GridSizeY < GridSizeMax)
			{
				TArray<FPrecomputedVisibilitySortGridCell> SortGrid;
				SortGrid.Empty(GridSizeX * GridSizeY);
				SortGrid.AddZeroed(GridSizeX * GridSizeY);

				// Add visibility cells into a 2d grid
				// Note that visibility data is duplicated so that the next pass can read from original neighbor visibility data
				for (int32 CellIndex = 0; CellIndex < CombinedPrecomputedVisibilityCells.Num(); CellIndex++)
				{
					float CellXFloat = (CombinedPrecomputedVisibilityCells[CellIndex].Bounds.GetCenter().X - AllCellsBounds.Min.X) / CellSize;
					int32 CellX = FMath::Clamp(FMath::TruncToInt(CellXFloat), 0, GridSizeX - 1);

					float CellYFloat = (CombinedPrecomputedVisibilityCells[CellIndex].Bounds.GetCenter().Y - AllCellsBounds.Min.Y) / CellSize;
					int32 CellY = FMath::Clamp(FMath::TruncToInt(CellYFloat), 0, GridSizeY - 1);

					FPrecomputedVisibilitySortGridCell& GridCell = SortGrid[CellY * GridSizeX + CellX];
					GridCell.Cells.Add(CombinedPrecomputedVisibilityCells[CellIndex]);
				}

				// Gather visibility from neighbors, using the 2d grid to accelerate the neighbor search
				for (int32 CellIndex = 0; CellIndex < CombinedPrecomputedVisibilityCells.Num(); CellIndex++)
				{
					FUncompressedPrecomputedVisibilityCell& CurrentCell = CombinedPrecomputedVisibilityCells[CellIndex];

					float CellXFloat = (CombinedPrecomputedVisibilityCells[CellIndex].Bounds.GetCenter().X - AllCellsBounds.Min.X) / CellSize;
					int32 CellX = FMath::Clamp(FMath::TruncToInt(CellXFloat), 0, GridSizeX - 1);

					float CellYFloat = (CombinedPrecomputedVisibilityCells[CellIndex].Bounds.GetCenter().Y - AllCellsBounds.Min.Y) / CellSize;
					int32 CellY = FMath::Clamp(FMath::TruncToInt(CellYFloat), 0, GridSizeY - 1);

					TotalNumQueries += CurrentCell.VisibilityData.Num() * 8;

					const FPrecomputedVisibilitySortGridCell& GridCell = SortGrid[CellY * GridSizeX + CellX];

					for (int32 YOffset = -1; YOffset <= 1; YOffset++)
					{
						for (int32 XOffset = -1; XOffset <= 1; XOffset++)
						{
							int32 FinalCellX = CellX + XOffset;
							int32 FinalCellY = CellY + YOffset;

							if (FinalCellX >= 0 && FinalCellX < GridSizeX && FinalCellY >= 0 && FinalCellY < GridSizeY)
							{
								const TArray<FUncompressedPrecomputedVisibilityCell, TInlineAllocator<2>>& CurrentSortCell = SortGrid[FinalCellY * GridSizeX + FinalCellX].Cells;

								for (int32 VisibilityCellIndex = 0; VisibilityCellIndex < CurrentSortCell.Num(); VisibilityCellIndex++)
								{
									const FUncompressedPrecomputedVisibilityCell& OtherCell = CurrentSortCell[VisibilityCellIndex];
									SpreadVisibilityCell(CellSize, PlayAreaHeight, OtherCell, CurrentCell, QueriesVisibleFromSpreadingNeighbors);
								}
							}
						}
					}
				}
			}
			else
			{
				// Brute force O(N^2) neighbor spreading version
				// Copy the original data since we read from outside the current cell
				TArray<FUncompressedPrecomputedVisibilityCell> OriginalPrecomputedVisibilityCells(CombinedPrecomputedVisibilityCells);
				for (int32 CellIndex = 0; CellIndex < CombinedPrecomputedVisibilityCells.Num(); CellIndex++)
				{
					FUncompressedPrecomputedVisibilityCell& CurrentCell = CombinedPrecomputedVisibilityCells[CellIndex];
					TotalNumQueries += CurrentCell.VisibilityData.Num() * 8;
					for (int32 OtherCellIndex = 0; OtherCellIndex < OriginalPrecomputedVisibilityCells.Num(); OtherCellIndex++)
					{
						const FUncompressedPrecomputedVisibilityCell& OtherCell = OriginalPrecomputedVisibilityCells[OtherCellIndex];

						SpreadVisibilityCell(CellSize, PlayAreaHeight, OtherCell, CurrentCell, QueriesVisibleFromSpreadingNeighbors);
					}
				}
			}
		}	

		const FVector2D CellBucketOriginXY(CombinedPrecomputedVisibilityCells[0].Bounds.Min.X, CombinedPrecomputedVisibilityCells[0].Bounds.Min.Y);

		TArray<TArray<const FUncompressedPrecomputedVisibilityCell*> > CellRenderingBuckets;
		CellRenderingBuckets.Empty(NumCellBuckets * NumCellBuckets);
		CellRenderingBuckets.AddZeroed(NumCellBuckets * NumCellBuckets);
		SIZE_T UncompressedSize = 0;
		// Sort the cells into buckets based on their position
		//@todo - sort cells inside buckets based on locality, to reduce visibility cache misses
		for (int32 CellIndex = 0; CellIndex < CombinedPrecomputedVisibilityCells.Num(); CellIndex++)
		{
			const FUncompressedPrecomputedVisibilityCell& CurrentCell = CombinedPrecomputedVisibilityCells[CellIndex];

			const float FloatOffsetX = (CurrentCell.Bounds.Min.X - CellBucketOriginXY.X + .5f * CellSize) / CellSize;
			// FMath::TruncToInt rounds toward 0, we want to always round down
			const int32 BucketIndexX = FMath::Abs((FMath::TruncToInt(FloatOffsetX) - (FloatOffsetX < 0.0f ? 1 : 0)) / CellBucketSize % NumCellBuckets);
			const float FloatOffsetY = (CurrentCell.Bounds.Min.Y - CellBucketOriginXY.Y + .5f * CellSize) / CellSize;
			const int32 BucketIndexY = FMath::Abs((FMath::TruncToInt(FloatOffsetY) - (FloatOffsetY < 0.0f ? 1 : 0)) / CellBucketSize % NumCellBuckets);

			const int32 BucketIndex = BucketIndexY * CellBucketSize + BucketIndexX;
			CellRenderingBuckets[BucketIndex].Add(&CurrentCell);
			UncompressedSize += CurrentCell.VisibilityData.Num();
		}

		System.GetWorld()->PersistentLevel->MarkPackageDirty();

		// Set all the level parameters needed to access visibility
		System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.PrecomputedVisibilityCellBucketOriginXY = CellBucketOriginXY;
		System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.PrecomputedVisibilityCellSizeXY = CellSize;
		System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.PrecomputedVisibilityCellSizeZ = PlayAreaHeight;
		System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.PrecomputedVisibilityCellBucketSizeXY = CellBucketSize;
		System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.PrecomputedVisibilityNumCellBuckets = NumCellBuckets;
		System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.PrecomputedVisibilityCellBuckets.Empty(NumCellBuckets * NumCellBuckets);
		System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.PrecomputedVisibilityCellBuckets.AddZeroed(NumCellBuckets * NumCellBuckets);

		// Split visibility data into ~32Kb chunks, to limit decompression time
		const int32 ChunkSizeTarget = 32 * 1024;
		TArray<uint8> UncompressedVisibilityData;
		SIZE_T TotalCompressedSize = 0;
		for (int32 BucketIndex = 0; BucketIndex < CellRenderingBuckets.Num(); BucketIndex++)
		{
			FPrecomputedVisibilityBucket& OutputBucket = System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.PrecomputedVisibilityCellBuckets[BucketIndex];
			OutputBucket.CellDataSize = CombinedPrecomputedVisibilityCells[0].VisibilityData.Num();
			int32 ChunkIndex = 0;
			UncompressedVisibilityData.Reset();
			for (int32 CellIndex = 0; CellIndex < CellRenderingBuckets[BucketIndex].Num(); CellIndex++)
			{	
				const FUncompressedPrecomputedVisibilityCell& CurrentCell = *CellRenderingBuckets[BucketIndex][CellIndex];
				FPrecomputedVisibilityCell NewCell;
				NewCell.Min = CurrentCell.Bounds.Min;
				// We're only storing Min per cell with a shared SizeXY and SizeZ for reduced memory storage
				checkSlow(CurrentCell.Bounds.Max.Equals(CurrentCell.Bounds.Min + FVector(CellSize, CellSize, PlayAreaHeight), KINDA_SMALL_NUMBER * 10.0f));
				NewCell.ChunkIndex = ChunkIndex;
				NewCell.DataOffset = UncompressedVisibilityData.Num();
				OutputBucket.Cells.Add(NewCell);
				UncompressedVisibilityData.Append(CurrentCell.VisibilityData);
				// Create a new chunk if we've reached the size limit or this is the last cell in a bucket
				if (UncompressedVisibilityData.Num() > ChunkSizeTarget || CellIndex == CellRenderingBuckets[BucketIndex].Num() - 1)
				{
					// Don't compress small amounts of data because FCompression::CompressMemory will fail
					if (bCompressVisibilityData && UncompressedVisibilityData.Num() > 32)
					{
						TArray<uint8> TempCompressionOutput;
						// Compressed output can be larger than the input, so we use temporary storage to hold the compressed output for now
						TempCompressionOutput.Empty(UncompressedVisibilityData.Num() * 4 / 3);
						TempCompressionOutput.AddUninitialized(UncompressedVisibilityData.Num() * 4 / 3);
						int32 CompressedSize = TempCompressionOutput.Num();
						verify(FCompression::CompressMemory(
							// Using zlib since it is supported on all platforms, otherwise we would need to compress on cook
							NAME_Zlib, 
							TempCompressionOutput.GetData(), 
							CompressedSize, 
							UncompressedVisibilityData.GetData(), 
							UncompressedVisibilityData.Num(),
							COMPRESS_BiasMemory));

						OutputBucket.CellDataChunks.AddZeroed();
						FCompressedVisibilityChunk& NewChunk = OutputBucket.CellDataChunks.Last();
						NewChunk.UncompressedSize = UncompressedVisibilityData.Num();
						NewChunk.bCompressed = true;
						NewChunk.Data.Empty(CompressedSize);
						NewChunk.Data.AddUninitialized(CompressedSize);
						FMemory::Memcpy(NewChunk.Data.GetData(), TempCompressionOutput.GetData(), CompressedSize);
						ChunkIndex++;
						TotalCompressedSize += CompressedSize;
						UncompressedVisibilityData.Reset();
					}
					else
					{
						OutputBucket.CellDataChunks.AddZeroed();
						FCompressedVisibilityChunk& NewChunk = OutputBucket.CellDataChunks.Last();
						NewChunk.UncompressedSize = UncompressedVisibilityData.Num();
						NewChunk.bCompressed = false;
						NewChunk.Data = UncompressedVisibilityData;
						ChunkIndex++;
						TotalCompressedSize += UncompressedVisibilityData.Num();
						UncompressedVisibilityData.Reset();
					}
				}
			}
		}

		System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.UpdateVisibilityStats(true);

		UE_LOG(LogStaticLightingSystem, Log, TEXT("ApplyPrecomputedVisibility %.1fs with %u cells, %.1f%% of all queries changed to visible from spreading neighbors, compressed %.3fMb to %.3fMb (%.1f ratio)"),
			FPlatformTime::Seconds() - StartTime,
			CombinedPrecomputedVisibilityCells.Num(),
			100.0f * QueriesVisibleFromSpreadingNeighbors / TotalNumQueries,
			UncompressedSize / 1024.0f / 1024.0f,
			TotalCompressedSize / 1024.0f / 1024.0f,
			UncompressedSize / (float)TotalCompressedSize);
	}
	else
	{
		System.GetWorld()->PersistentLevel->PrecomputedVisibilityHandler.Invalidate(System.GetWorld()->Scene);
	}
}

/** Imports data from Lightmass about the mesh area lights generated for the scene, and creates AGeneratedMeshAreaLight's for them. */
void FLightmassProcessor::ImportMeshAreaLightData()
{
	if (MeshAreaLightDataTaskCompleted > 0)
	{
		const FString ChannelName = Lightmass::CreateChannelName(Lightmass::MeshAreaLightDataGuid, Lightmass::LM_MESHAREALIGHTDATA_VERSION, Lightmass::LM_MESHAREALIGHTDATA_EXTENSION);
		const int32 Channel = Swarm.OpenChannel( *ChannelName, LM_MESHAREALIGHT_CHANNEL_FLAGS );
		if (Channel >= 0)
		{
			int32 NumMeshAreaLights = 0;
			Swarm.ReadChannel(Channel, &NumMeshAreaLights, sizeof(NumMeshAreaLights));
			for (int32 LightIndex = 0; LightIndex < NumMeshAreaLights; LightIndex++)
			{
				Lightmass::FMeshAreaLightData LMCurrentLightData;
				Swarm.ReadChannel(Channel, &LMCurrentLightData, sizeof(LMCurrentLightData));
				const ULevel* CurrentLevel = System.LightingContext.GetLevelForGuid(LMCurrentLightData.LevelGuid).Get();
				if (CurrentLevel && CurrentLevel->Actors.Num() > 0)
				{
					// Find the level that the mesh area light was in
					FVector4 Position;
					Position = (FVector4)LMCurrentLightData.Position;
					FVector4 Direction;
					Direction = (FVector4)LMCurrentLightData.Direction;
					// Spawn a AGeneratedMeshAreaLight to handle the light's influence on dynamic objects
					FActorSpawnParameters SpawnInfo;
					SpawnInfo.Owner = CurrentLevel->GetWorldSettings();
					AGeneratedMeshAreaLight* NewGeneratedLight = CurrentLevel->OwningWorld->SpawnActor<AGeneratedMeshAreaLight>(Position, Direction.Rotation());
					USpotLightComponent* SpotComponent = CastChecked<USpotLightComponent>(NewGeneratedLight->GetLightComponent());
					// Unregister the component before we change its attributes
					FComponentReregisterContext Reregister(SpotComponent);
					// Setup spotlight properties to approximate a mesh area light
					SpotComponent->AttenuationRadius = LMCurrentLightData.Radius;
					SpotComponent->OuterConeAngle = LMCurrentLightData.ConeAngle * 180.0f / PI;
					SpotComponent->LightColor = LMCurrentLightData.Color;
					SpotComponent->Intensity = LMCurrentLightData.Brightness;
					SpotComponent->LightFalloffExponent = LMCurrentLightData.FalloffExponent;
				}
			}
			Swarm.CloseChannel(Channel);
		}
		else
		{
			UE_LOG(LogLightmassSolver, Log,  TEXT("Error, OpenChannel failed to open %s with error code %d"), *ChannelName, Channel );
		}
		FPlatformAtomics::InterlockedExchange(&MeshAreaLightDataTaskCompleted, 0);
	}
}


/** Imports the volume distance field from Lightmass. */
void FLightmassProcessor::ImportVolumeDistanceFieldData()
{
	if (VolumeDistanceFieldTaskCompleted > 0)
	{
		const FString ChannelName = Lightmass::CreateChannelName(Lightmass::VolumeDistanceFieldGuid, Lightmass::LM_MESHAREALIGHTDATA_VERSION, Lightmass::LM_MESHAREALIGHTDATA_EXTENSION);
		const int32 Channel = Swarm.OpenChannel( *ChannelName, LM_MESHAREALIGHT_CHANNEL_FLAGS );
		if (Channel >= 0)
		{
			FPrecomputedVolumeDistanceField& DistanceField = System.GetWorld()->PersistentLevel->PrecomputedVolumeDistanceField;
			Swarm.ReadChannel(Channel, &DistanceField.VolumeSizeX, sizeof(DistanceField.VolumeSizeX));
			Swarm.ReadChannel(Channel, &DistanceField.VolumeSizeY, sizeof(DistanceField.VolumeSizeY));
			Swarm.ReadChannel(Channel, &DistanceField.VolumeSizeZ, sizeof(DistanceField.VolumeSizeZ));
			Swarm.ReadChannel(Channel, &DistanceField.VolumeMaxDistance, sizeof(DistanceField.VolumeMaxDistance));
			
			FVector4 BoxMin;
			Swarm.ReadChannel(Channel, &BoxMin, sizeof(BoxMin));
			FVector4 BoxMax;
			Swarm.ReadChannel(Channel, &BoxMax, sizeof(BoxMax));
			DistanceField.VolumeBox = FBox(BoxMin, BoxMax);

			ReadArray(Channel, DistanceField.Data);

			Swarm.CloseChannel(Channel);
		}
		else
		{
			UE_LOG(LogLightmassSolver, Log,  TEXT("Error, OpenChannel failed to open %s with error code %d"), *ChannelName, Channel );
		}
		FPlatformAtomics::InterlockedExchange(&VolumeDistanceFieldTaskCompleted, 0);
	}
}

/**
 *	Import the texture mapping 
 *	@param	TextureMapping			The mapping being imported.
 *	@param	bProcessImmediately		If true, immediately process the mapping
 *									If false, store it off for later processing
 */
void FLightmassProcessor::ImportStaticLightingTextureMapping( const FGuid& MappingGuid, bool bProcessImmediately )
{
	FString ChannelName = Lightmass::CreateChannelName(MappingGuid, Lightmass::LM_TEXTUREMAPPING_VERSION, Lightmass::LM_TEXTUREMAPPING_EXTENSION);

	// We need to check if there's a channel with this name for each completed mapping,
	// even if the mapping has been imported as part of a previous channel.
	// Example:
	// 1. If the remote agent gets reassigned, it might have written out a merged channel
	//    (mappings A, B, C and D in one channel) but only sent out a "completed" message for
	//    some of the mappings (e.g. A and B).
	// 2. Unreal imports A, B, C and D when it receives the "completed" message for A.
	// 3. A new remote agent will process C, D and some new mappings E and F, and write out
	//    a merged channel named "C", containing C, D, E, F.
	// 4. Unreal must now read the "C" channel - even if C has been imported already - in order
	//    to import E and F.
	int32 Channel = Swarm.OpenChannel( *ChannelName, LM_TEXTUREMAPPING_CHANNEL_FLAGS );
	if (Channel >= 0)
	{
		// Read in how many mappings this channel contains
		uint32 MappingsImported = 0;
		uint32 NumMappings = 0;
		Swarm.ReadChannel(Channel, &NumMappings, sizeof(NumMappings));

		// Read in each of the mappings
		while (MappingsImported != NumMappings)
		{
			// Read in the next GUID and look up its mapping
			FGuid NextMappingGuid;
			Swarm.ReadChannel(Channel, &NextMappingGuid, sizeof(FGuid));
			FStaticLightingTextureMapping* TextureMapping = GetStaticLightingTextureMapping(NextMappingGuid);

			if (TextureMapping && !TextureMapping->IsValidMapping())
			{
				// Mapping is invalid (such as in the case of BSP being invalidated), discard the rest of the file
				break;
			}

			// If we don't have a mapping pending, check to see if we've already imported
			// it which can *possibly* happen if a disconnection race condition occured
			// where we got the results for a task, but didn't get the message that it
			// had finished before we re-queued/re-assigned the task to another agent,
			// which could result in duplicate results. If we get a duplicate, just
			// re-import the redundant results.
			bool bReimporting = false;
			if ( TextureMapping == NULL )
			{
				// Remove the mapping from ImportedMappings and re-import it.
				FMappingImportHelper** pImportData = ImportedMappings.Find( NextMappingGuid );
				check( pImportData && *pImportData && (*pImportData)->Type == SLT_Texture );
				FTextureMappingImportHelper* pTextureImportData = (*pImportData)->GetTextureMappingHelper();
				TextureMapping = pTextureImportData->TextureMapping.GetReference();
				bReimporting = true;
				if ( GLightmassStatsMode )
				{
					UE_LOG(LogLightmassSolver, Log, TEXT("Re-importing texture mapping: %s"), *NextMappingGuid.ToString());
				}
			}

			if( ensureMsgf( (TextureMapping != NULL), TEXT("Opened mapping channel %s to Swarm, then tried to find texture mapping %s (number %d of %d) and failed."), *MappingGuid.ToString(), *NextMappingGuid.ToString(), MappingsImported, NumMappings) )
			{
				//UE_LOG(LogLightmassSolver, Log, TEXT("Importing %32s %s"), *(TextureMapping->GetDescription()), *(TextureMapping->GetLightingGuid().ToString()));

				FTextureMappingImportHelper* ImportData = new FTextureMappingImportHelper();
				ImportData->TextureMapping = TextureMapping;
				ImportData->MappingGuid = NextMappingGuid;
				if (ImportTextureMapping(Channel, *ImportData) == true)
				{
					if ( bReimporting == false )
					{
						ImportedMappings.Add(ImportData->MappingGuid, ImportData);
					}
					if (bProcessImmediately)
					{
						ProcessMapping(ImportData->MappingGuid);
					}
				}
				else
				{
					UE_LOG(LogLightmassSolver, Warning, TEXT("Failed to import TEXTure mapping results!"));
				}

				// Completed this mapping, increment
				MappingsImported++;
			}
			else
			{
				// Report an error for this mapping
				UObject* Object = NULL;
				const FStaticLightingMapping* FoundMapping = Exporter->FindMappingByGuid(NextMappingGuid);
				if (FoundMapping)
				{
					Object = FoundMapping->GetMappedObject();
				}

				FMessageLog("LightingResults").Error()
					->AddToken(FUObjectToken::Create(Object))
					->AddToken(FTextToken::Create(LOCTEXT("LightmassError_LightingBuildError", "Lighting build error")));

				// We can't trust the rest of this file, so we'll need to bail now
				break;
			}
		}
		Swarm.CloseChannel( Channel );
	}
	// File not found?
	else if ( Channel == NSwarm::SWARM_ERROR_CHANNEL_NOT_FOUND )
	{
		// If the channel doesn't exist, then this mapping could've been part of another channel
		// that has already been imported, so attempt to remove the mapping
		FStaticLightingTextureMapping* TextureMapping = GetStaticLightingTextureMapping(MappingGuid);
		// Alternatively, this channel could be part of an invalidated mapping
	}
	// Other error
	else
	{
		UE_LOG(LogLightmassSolver, Log,  TEXT("Error, OpenChannel failed to open %s with error code %d"), *ChannelName, Channel );
	}
}

/** Determines whether the specified mapping is a texture mapping */
bool FLightmassProcessor::IsStaticLightingTextureMapping( const FGuid& MappingGuid )
{
	if (PendingBSPMappings.Contains(MappingGuid))
	{
		return true;
	}
	else if (PendingTextureMappings.Contains(MappingGuid))
	{
		return true;
	}
	else if (PendingLandscapeMappings.Contains(MappingGuid))
	{
		return true;
	}
	else
	{
		FMappingImportHelper** pImportData = ImportedMappings.Find(MappingGuid);
		if ( pImportData && (*pImportData)->Type == SLT_Texture )
		{
			return true;
		}
	}
	return false;
}

/** Gets the texture mapping for the specified GUID */
FStaticLightingTextureMapping* FLightmassProcessor::GetStaticLightingTextureMapping( const FGuid& MappingGuid )
{
	FBSPSurfaceStaticLighting* BSPMapping = NULL;
	FStaticMeshStaticLightingTextureMapping* SMTextureMapping = NULL;
	FLandscapeStaticLightingTextureMapping* LandscapeMapping = NULL;

	if (PendingBSPMappings.RemoveAndCopyValue(MappingGuid, BSPMapping))
	{
		return BSPMapping->GetTextureMapping();
	}
	else if (PendingTextureMappings.RemoveAndCopyValue(MappingGuid, SMTextureMapping))
	{
		return SMTextureMapping->GetTextureMapping();
	}
	else if (PendingLandscapeMappings.RemoveAndCopyValue(MappingGuid, LandscapeMapping))
	{
		return LandscapeMapping->GetTextureMapping();
	}
	return NULL;
}

void FLightmassProcessor::ImportStaticShadowDepthMap(ULightComponent* Light)
{
	const FString ChannelName = Lightmass::CreateChannelName(Light->LightGuid, Lightmass::LM_DOMINANTSHADOW_VERSION, Lightmass::LM_DOMINANTSHADOW_EXTENSION);
	const int32 Channel = Swarm.OpenChannel( *ChannelName, LM_DOMINANTSHADOW_CHANNEL_FLAGS );
	if (Channel >= 0)
	{
		UMapBuildDataRegistry* CurrentRegistry = System.LightingContext.GetOrCreateRegistryForActor(Light->GetOwner());
		FLightComponentMapBuildData& CurrentLightData = CurrentRegistry->FindOrAllocateLightBuildData(Light->LightGuid, true);

		Lightmass::FStaticShadowDepthMapData ShadowMapData;
		Swarm.ReadChannel(Channel, &ShadowMapData, sizeof(ShadowMapData));

		BeginReleaseResource(&Light->StaticShadowDepthMap);
		CurrentLightData.DepthMap.Empty();

		CurrentLightData.DepthMap.WorldToLight = FMatrix(ShadowMapData.WorldToLight);
		CurrentLightData.DepthMap.ShadowMapSizeX = ShadowMapData.ShadowMapSizeX;
		CurrentLightData.DepthMap.ShadowMapSizeY = ShadowMapData.ShadowMapSizeY;

		ReadArray(Channel, CurrentLightData.DepthMap.DepthSamples);
		Swarm.CloseChannel(Channel);

		CurrentLightData.FinalizeLoad();
	}
	else
	{
		UE_LOG(LogLightmassSolver, Log,  TEXT("Error, OpenChannel failed to open %s with error code %d"), *ChannelName, Channel );
	}
}

/**
 * Import the mapping specified by a Guid.
 *	@param MappingGuid				Guid that identifies a mapping
 *	@param	bProcessImmediately		If true, immediately process the mapping
 *									If false, store it off for later processing
 */
void FLightmassProcessor::ImportMapping( const FGuid& MappingGuid, bool bProcessImmediately )
{
	double ImportAndApplyStartTime = FPlatformTime::Seconds();
	double OriginalApplyTime = Statistics.ApplyTimeInProcessing;

	if (IsStaticLightingTextureMapping(MappingGuid))
	{
		ImportStaticLightingTextureMapping(MappingGuid, bProcessImmediately);
	}
	else
	{
		ULightComponent* Light = FindLight(MappingGuid);

		if (Light)
		{
			ImportStaticShadowDepthMap(Light);
		}
		else
		{
			FMappingImportHelper** pImportData = ImportedMappings.Find(MappingGuid);
			if ((pImportData == NULL) || (*pImportData == NULL))
			{
				UE_LOG(LogLightmassSolver, Warning, TEXT("Mapping not found for %s"), *(MappingGuid.ToString()));
			}
		}
	}

	if ( !bRunningLightmass )
	{
		double ApplyTime = Statistics.ApplyTimeInProcessing - OriginalApplyTime;
		double ImportTime = FPlatformTime::Seconds() - ImportAndApplyStartTime - ApplyTime;
		Statistics.ImportTimeInProcessing += ImportTime;
	}
}

/**
 * Process the mapping specified by a Guid.
 * @param MappingGuid	Guid that identifies a mapping
 **/
void FLightmassProcessor::ProcessMapping( const FGuid& MappingGuid )
{
	double ApplyStartTime = FPlatformTime::Seconds();

	FMappingImportHelper** pImportData = ImportedMappings.Find(MappingGuid);
	if ( pImportData && *pImportData )
	{
		if ( (*pImportData)->bProcessed == false )
		{
			FMappingImportHelper* ImportData = *pImportData;
			switch (ImportData->Type)
			{
			case SLT_Texture:
				{
					FTextureMappingImportHelper* TImportData = (FTextureMappingImportHelper*)ImportData;
					if(TImportData->TextureMapping)
					{
						//UE_LOG(LogLightmassSolver, Log, TEXT("Processing %32s: %s"), *(TImportData->TextureMapping->GetDescription()), *(TImportData->TextureMapping->GetLightingGuid().ToString()));
						System.ApplyMapping(TImportData->TextureMapping, TImportData->QuantizedData, TImportData->ShadowMapData);
					}
					else
					{
						//UE_LOG(LogLightmassSolver, Log, TEXT("Processing texture mapping %s failed due to missing mapping!"), *MappingGuid.ToString());
					}
				}
				break;
			default:
				{
					UE_LOG(LogLightmassSolver, Warning, TEXT("Unknown mapping type in the ImportedMappings: 0x%08x"), (uint32)(ImportData->Type));
				}
			}

			(*pImportData)->bProcessed = true;
		}
		else
		{
			// Just to be able to set a breakpoint here.
			int32 DebugDummy = 0;
		}
	}
	else
	{
		UE_LOG(LogLightmassSolver, Warning, TEXT("Failed to find imported mapping %s"), *(MappingGuid.ToString()));
	}

	if ( !bRunningLightmass )
	{
		Statistics.ApplyTimeInProcessing += FPlatformTime::Seconds() - ApplyStartTime;
	}
}

/**
 * Process any available mappings.
 **/
void FLightmassProcessor::ProcessAvailableMappings()
{
	bool bDoneProcessing = false;
	int32 ProcessedCount = 0;
	int32 ImportedMappingsCount = ImportedMappings.Num();
	while (!bDoneProcessing)
	{
		FGuid NextGuid = FGuid(0,0,0,MappingToProcessIndex);
		FMappingImportHelper** pImportData = ImportedMappings.Find(NextGuid);
		if (pImportData)
		{
			if ( *pImportData && (*pImportData)->bProcessed == false )
			{
				if (IsDeferredMapping(NextGuid))
				{
					DeferMapping((*pImportData)->GetTextureMappingHelper());
				}
				else
				{
					ProcessMapping(NextGuid);
				}
			}
			ProcessedCount++;
		}

		MappingToProcessIndex++;

		if (ProcessedCount >= ImportedMappingsCount)
		{
			bDoneProcessing = true;
		}
	}
}

void FLightmassProcessor::ImportDebugOutputStruct(int32 Channel)
{
	static_assert(sizeof(FDebugStaticLightingRay) == sizeof(Lightmass::FDebugStaticLightingRay), "Debug type sizes must match for FDebugStaticLightingRay.");
	static_assert(sizeof(FDebugStaticLightingVertex) == sizeof(Lightmass::FDebugStaticLightingVertex), "Debug type sizes must match for FDebugStaticLightingVertex.");
	static_assert(sizeof(FDebugLightingCacheRecord) == sizeof(Lightmass::FDebugLightingCacheRecord), "Debug type sizes must match for FDebugLightingCacheRecord.");
	static_assert(STRUCT_OFFSET(FDebugLightingCacheRecord, RecordId) == STRUCT_OFFSET(Lightmass::FDebugLightingCacheRecord, RecordId), "Debug struct offset must match for FDebugLightingCacheRecord::RecordId.");
	static_assert(sizeof(FDebugPhoton) == sizeof(Lightmass::FDebugPhoton), "Debug type sizes must match for FDebugPhoton.");
	static_assert(sizeof(FDebugOctreeNode) == sizeof(Lightmass::FDebugOctreeNode), "Debug type sizes must match for FDebugOctreeNode.");
	static_assert(NumTexelCorners == Lightmass::NumTexelCorners, "Debug type sizes must match for NumTexelCorners.");

	bool bDebugInfoValid = false;
	Swarm.ReadChannel(Channel, &bDebugInfoValid, sizeof(bDebugInfoValid));

	if (bDebugInfoValid)
	{
		if (GDebugStaticLightingInfo.bValid)
		{
			UE_LOG(LogLightmassSolver, Log, TEXT("Error, importing valid debug info, but GDebugStaticLightingInfo was already valid (multiple sources of debug info from Lightmass)"));
		}

		GDebugStaticLightingInfo.bValid = true;
		ReadArray(Channel, GDebugStaticLightingInfo.PathRays);
		ReadArray(Channel, GDebugStaticLightingInfo.ShadowRays);
		ReadArray(Channel, GDebugStaticLightingInfo.IndirectPhotonPaths);
		ReadArray(Channel, GDebugStaticLightingInfo.SelectedVertexIndices);
		ReadArray(Channel, GDebugStaticLightingInfo.Vertices);
		ReadArray(Channel, GDebugStaticLightingInfo.CacheRecords);
		ReadArray(Channel, GDebugStaticLightingInfo.DirectPhotons);
		ReadArray(Channel, GDebugStaticLightingInfo.IndirectPhotons);
		ReadArray(Channel, GDebugStaticLightingInfo.IrradiancePhotons);
		ReadArray(Channel, GDebugStaticLightingInfo.GatheredPhotons);
		ReadArray(Channel, GDebugStaticLightingInfo.GatheredImportancePhotons);
		ReadArray(Channel, GDebugStaticLightingInfo.GatheredPhotonNodes);
		Swarm.ReadChannel(Channel, &GDebugStaticLightingInfo.bDirectPhotonValid, sizeof(GDebugStaticLightingInfo.bDirectPhotonValid));
		Swarm.ReadChannel(Channel, &GDebugStaticLightingInfo.GatheredDirectPhoton, sizeof(GDebugStaticLightingInfo.GatheredDirectPhoton));
		Swarm.ReadChannel(Channel, &GDebugStaticLightingInfo.TexelCorners, sizeof(GDebugStaticLightingInfo.TexelCorners));
		Swarm.ReadChannel(Channel, &GDebugStaticLightingInfo.bCornerValid, sizeof(GDebugStaticLightingInfo.bCornerValid));
		Swarm.ReadChannel(Channel, &GDebugStaticLightingInfo.SampleRadius, sizeof(GDebugStaticLightingInfo.SampleRadius));
	}
}

/**
 *	Retrieve the light for the given Guid
 *
 *	@param	LightGuid			The guid of the light we are looking for
 *
 *	@return	ULightComponent*	The corresponding light component.
 *								NULL if not found.
 */
ULightComponent* FLightmassProcessor::FindLight(const FGuid& LightGuid)
{
	if (Exporter)
	{
		int32 LightIndex;
		for (LightIndex = 0; LightIndex < Exporter->DirectionalLights.Num(); LightIndex++)
		{
			const UDirectionalLightComponent* Light = Exporter->DirectionalLights[LightIndex];
			if (Light)
			{
				if (Light->LightGuid == LightGuid)
				{
					return (ULightComponent*)Light;
				}
			}
		}
		for (LightIndex = 0; LightIndex < Exporter->PointLights.Num(); LightIndex++)
		{
			const UPointLightComponent* Light = Exporter->PointLights[LightIndex];
			if (Light)
			{
				if (Light->LightGuid == LightGuid)
				{
					return (ULightComponent*)Light;
				}
			}
		}
		for (LightIndex = 0; LightIndex < Exporter->SpotLights.Num(); LightIndex++)
		{
			const USpotLightComponent* Light = Exporter->SpotLights[LightIndex];
			if (Light)
			{
				if (Light->LightGuid == LightGuid)
				{
					return (ULightComponent*)Light;
				}
			}
		}
		for (LightIndex = 0; LightIndex < Exporter->RectLights.Num(); LightIndex++)
		{
			const URectLightComponent* Light = Exporter->RectLights[LightIndex];
			if (Light)
			{
				if (Light->LightGuid == LightGuid)
				{
					return (ULightComponent*)Light;
				}
			}
		}
	}

	return NULL;
}

/**
 *	Retrieve the static mehs for the given Guid
 *
 *	@param	Guid				The guid of the static mesh we are looking for
 *
 *	@return	UStaticMesh*		The corresponding static mesh.
 *								NULL if not found.
 */
UStaticMesh* FLightmassProcessor::FindStaticMesh(FGuid& Guid)
{
	if (Exporter)
	{
		for (int32 SMIdx = 0; SMIdx < Exporter->StaticMeshes.Num(); SMIdx++)
		{
			const UStaticMesh* StaticMesh = Exporter->StaticMeshes[SMIdx];
			if (StaticMesh && (StaticMesh->GetLightingGuid() == Guid))
			{
				return (UStaticMesh*)StaticMesh;
			}
		}
	}
	return NULL;
}

ULevel* FLightmassProcessor::FindLevel(const FGuid& Guid)
{
	if (Exporter)
	{
		const TWeakObjectPtr<ULevel> Level = Exporter->LightingContext.GetLevelForGuid(Guid);
		return Level.IsValid() ? Level.Get() : NULL;
	}
	return NULL;
}

/**
 *	Import light map data from the given channel.
 *
 *	@param	Channel				The channel to import from.
 *	@param	QuantizedData		The quantized lightmap data to fill in
 *	@param	UncompressedSize	Size the data will be after uncompressing it (if compressed)
 *	@param	CompressedSize		Size of the source data if compressed
 *
 *	@return	bool				true if successful, false otherwise.
 */
bool FLightmassProcessor::ImportLightMapData2DData(int32 Channel, FQuantizedLightmapData* QuantizedData, int32 UncompressedSize, int32 CompressedSize)
{
	check(QuantizedData);
	
	int32 SizeX = QuantizedData->SizeX;
	int32 SizeY = QuantizedData->SizeY;

	// make space for the samples
	QuantizedData->Data.Empty(SizeX * SizeY);
	QuantizedData->Data.AddUninitialized(SizeX * SizeY);
	FLightMapCoefficients* DataBuffer = QuantizedData->Data.GetData();

	int32 DataBufferSize = SizeX * SizeY * sizeof(FLightMapCoefficients);

	check(DataBufferSize == UncompressedSize);

	// read in the compressed data
	void* CompressedBuffer = FMemory::Malloc(CompressedSize);
	Swarm.ReadChannel(Channel, CompressedBuffer, CompressedSize);

	// decompress the temp buffer into another temp buffer 
	if (!FCompression::UncompressMemory(NAME_Zlib, DataBuffer, UncompressedSize, CompressedBuffer, CompressedSize))
	{
		checkf(false, TEXT("Uncompress failed, which is unexpected"));
	}

	// can free one buffer now
	FMemory::Free(CompressedBuffer);

	return true;
}

bool FLightmassProcessor::ImportSignedDistanceFieldShadowMapData2D(int32 Channel, TMap<ULightComponent*,FShadowMapData2D*>& OutShadowMapData, int32 ShadowMapCount)
{
	for (int32 SMIndex = 0; SMIndex < ShadowMapCount; SMIndex++)
	{
		FGuid LightGuid;
		Swarm.ReadChannel(Channel, &LightGuid, sizeof(FGuid));

		ULightComponent* LightComp = FindLight(LightGuid);
		if (LightComp == NULL)
		{
			UE_LOG(LogLightmassSolver, Warning, TEXT("Failed to find light for texture mapping: %s"), *LightGuid.ToString());
		}

		Lightmass::FShadowMapData2DData SMData(0,0);
		Swarm.ReadChannel(Channel, &SMData, sizeof(Lightmass::FShadowMapData2DData));

		static_assert(sizeof(FQuantizedSignedDistanceFieldShadowSample) == sizeof(Lightmass::FQuantizedSignedDistanceFieldShadowSampleData), "Sample data sizes must match.");

		FQuantizedShadowSignedDistanceFieldData2D* ShadowMapData = new FQuantizedShadowSignedDistanceFieldData2D(SMData.SizeX, SMData.SizeY);
		check(ShadowMapData);

		FQuantizedSignedDistanceFieldShadowSample* DataBuffer = ShadowMapData->GetData();
		uint32 DataBufferSize = SMData.SizeX * SMData.SizeY * sizeof(Lightmass::FQuantizedSignedDistanceFieldShadowSampleData);

		uint32 CompressedSize = SMData.CompressedDataSize;
		uint32 UncompressedSize = SMData.UncompressedDataSize;
		check(DataBufferSize == UncompressedSize);

		// Read in the compressed data
		void* CompressedBuffer = FMemory::Malloc(CompressedSize);
		Swarm.ReadChannel(Channel, CompressedBuffer, CompressedSize);

		// Decompress the temp buffer into another temp buffer 
		if (!FCompression::UncompressMemory(NAME_Zlib, DataBuffer, UncompressedSize, CompressedBuffer, CompressedSize))
		{
			checkf(false, TEXT("Uncompress failed, which is unexpected"));
		}
		FMemory::Free(CompressedBuffer);

		if (LightComp)
		{
			OutShadowMapData.Add(LightComp, ShadowMapData);
		}
		else
		{
			delete ShadowMapData;
		}
	}

	return true;
}

/**
 *	Import a complete texture mapping....
 *
 *	@param	Channel			The channel to import from.
 *	@param	TMImport		The texture mapping information that will be imported.
 *
 *	@return	bool			true if successful, false otherwise.
 */
bool FLightmassProcessor::ImportTextureMapping(int32 Channel, FTextureMappingImportHelper& TMImport)
{
	bool bResult = true;

	// Additional information for this mapping
	Swarm.ReadChannel(Channel, &(TMImport.ExecutionTime), sizeof(double));

	// The resulting light map data for this mapping (shared header and TArray) 
	Lightmass::FLightMapData2DData LMLightmapData2DData(0,0);
	Swarm.ReadChannel(Channel, &LMLightmapData2DData, sizeof(Lightmass::FLightMapData2DData));
	check(TMImport.TextureMapping->SizeX == LMLightmapData2DData.SizeX);
	check(TMImport.TextureMapping->SizeY == LMLightmapData2DData.SizeY);
	Swarm.ReadChannel(Channel, &TMImport.NumShadowMaps, sizeof(TMImport.NumShadowMaps));
	Swarm.ReadChannel(Channel, &TMImport.NumSignedDistanceFieldShadowMaps, sizeof(TMImport.NumSignedDistanceFieldShadowMaps));

	int32 NumLights = 0;
	TArray<FGuid> LightGuids;
	LightGuids.Empty(NumLights);
	Swarm.ReadChannel(Channel, &NumLights, sizeof(NumLights));
	for (int32 i = 0; i < NumLights; i++)
	{
		const int32 NewLightIndex = LightGuids.AddUninitialized();
		Swarm.ReadChannel(Channel, &LightGuids[NewLightIndex], sizeof(LightGuids[NewLightIndex]));
	}

	// allocate space to store the quantized data
	TMImport.QuantizedData = new FQuantizedLightmapData;
	FMemory::Memcpy(TMImport.QuantizedData->Scale, LMLightmapData2DData.Multiply, sizeof(TMImport.QuantizedData->Scale));
	FMemory::Memcpy(TMImport.QuantizedData->Add, LMLightmapData2DData.Add, sizeof(TMImport.QuantizedData->Add));
	TMImport.QuantizedData->SizeX = LMLightmapData2DData.SizeX;
	TMImport.QuantizedData->SizeY = LMLightmapData2DData.SizeY;
	TMImport.QuantizedData->LightGuids = LightGuids;
	TMImport.QuantizedData->bHasSkyShadowing = LMLightmapData2DData.bHasSkyShadowing;

	if (ImportLightMapData2DData(Channel, TMImport.QuantizedData, LMLightmapData2DData.UncompressedDataSize, LMLightmapData2DData.CompressedDataSize) == false)
	{
		bResult = false;
	}

	int32 NumUnmappedTexels = 0;
	for (int32 DebugIdx = 0; DebugIdx < TMImport.QuantizedData->Data.Num(); DebugIdx++)
	{
		if (TMImport.QuantizedData->Data[DebugIdx].Coverage == 0.0f)
		{
			NumUnmappedTexels++;
		}
	}

	if (TMImport.QuantizedData->Data.Num() > 0)
	{
		TMImport.UnmappedTexelsPercentage = 100.0f * (float)NumUnmappedTexels / (float)TMImport.QuantizedData->Data.Num();
	}
	else
	{
		TMImport.UnmappedTexelsPercentage = 0.0f;
	}

	if (ImportSignedDistanceFieldShadowMapData2D(Channel, TMImport.ShadowMapData, TMImport.NumSignedDistanceFieldShadowMaps) == false)
	{
		bResult = false;
	}

	ImportDebugOutputStruct(Channel);

	// Update the LightingBuildInfo list
	UObject* MappedObject = TMImport.TextureMapping->GetMappedObject();
	float MemoryAmount = float(NumUnmappedTexels);
	float TotalMemoryAmount = float(TMImport.QuantizedData->Data.Num());
	//@todo. Move this into some common place... it's defined in several places now!
	const float MIP_FACTOR = 4.0f / 3.0f;
	// Assume compressed == 4 bits/pixel, really this is platform specific.
	float BytesPerPixel = 1.0f;

	float LightMapTypeModifier = NUM_HQ_LIGHTMAP_COEF;
	if (!AllowHighQualityLightmaps(GMaxRHIFeatureLevel))
	{
		LightMapTypeModifier = NUM_LQ_LIGHTMAP_COEF;
	}

	int32 WastedMemory = FMath::TruncToInt(MemoryAmount * BytesPerPixel * MIP_FACTOR * LightMapTypeModifier);
	int32 TotalMemory = FMath::TruncToInt(TotalMemoryAmount * BytesPerPixel * MIP_FACTOR * LightMapTypeModifier);
	
	FStatsViewerModule& StatsViewerModule = FModuleManager::Get().LoadModuleChecked<FStatsViewerModule>(TEXT("StatsViewer"));
	ULightingBuildInfo* LightingBuildInfo = NewObject<ULightingBuildInfo>();
	LightingBuildInfo->Set( MappedObject, TMImport.ExecutionTime, TMImport.UnmappedTexelsPercentage, WastedMemory, TotalMemory );
	StatsViewerModule.GetPage(EStatsPage::LightingBuildInfo)->AddEntry( LightingBuildInfo );

	return bResult;
}

void FLightmassProcessor::FMappingImportHelper::Serialize(FArchive& Ar)
{
	static_assert(sizeof(Type) == sizeof(int32));
	Ar << (int32&)Type;
	Ar << MappingGuid;
	Ar << OwnerGuid;
	Ar << ExecutionTime;
	Ar << bProcessed;
}

void FLightmassProcessor::FTextureMappingImportHelper::Serialize(FArchive& Ar)
{
	FMappingImportHelper::Serialize(Ar);

	if (Ar.IsLoading())
	{
		int32 MappingType;
		Ar << MappingType;
		
		switch (MappingType)
		{
			case 0:
				TextureMapping = new FStaticMeshStaticLightingTextureMapping(Ar);
				break;
			case 1:
				TextureMapping = new FLandscapeStaticLightingTextureMapping(Ar);
				break;			
			case 2:
				TextureMapping = new FStaticLightingTextureMapping_InstancedStaticMesh(Ar);
		}
		
		// Ptr will be deleted during FStaticLightingTextureMapping::Apply
		QuantizedData = new FQuantizedLightmapData;
	}
	else
	{
		static  TMap<FString, int32> DescToType = {{"SMTextureMapping", 0}, { "LandscapeMapping", 1 }, {"InstancedSMLightingMapping", 2}};
		
		int32  mappingType = DescToType.FindChecked(TextureMapping->GetDescription());
		Ar << mappingType;
	}

	TextureMapping->Serialize(Ar);
	QuantizedData->Serialize(Ar);
	
	Ar << UnmappedTexelsPercentage;
	Ar << NumShadowMaps;
	Ar << NumSignedDistanceFieldShadowMaps;

	int32 NbShadowMapData = ShadowMapData.Num();
	Ar << NbShadowMapData;

	if (Ar.IsLoading())
	{
		for (int32 i = 0; i < NbShadowMapData; i++)
		{
			FSoftObjectPath	Path;
			Ar << Path;

			int32 ShadowMapType;
			Ar << ShadowMapType;

			int32 SizeX;
			int32 SizeY;
			Ar << SizeX;
			Ar << SizeY;

			// Ptr will be deleted during FStaticLightingTextureMapping::Apply
			FShadowMapData2D* Data = nullptr;

			switch ((FShadowMapData2D::ShadowMapDataType)ShadowMapType)
			{
				case FShadowMapData2D::SHADOW_SIGNED_DISTANCE_FIELD_DATA:
					Data = new FShadowSignedDistanceFieldData2D(SizeX, SizeY);
					break;
				case FShadowMapData2D::SHADOW_SIGNED_DISTANCE_FIELD_DATA_QUANTIZED:
					Data = new FQuantizedShadowSignedDistanceFieldData2D(SizeX, SizeY);
					break;

				default:
				case FShadowMapData2D::SHADOW_FACTOR_DATA:
				case FShadowMapData2D::SHADOW_FACTOR_DATA_QUANTIZED:
					ensure(false);
					return;
			}

			Data->Serialize(&Ar);

			ShadowMapData.Add(Cast<ULightComponent>(Path.ResolveObject()), Data);
		}
	}
	else
	{
		for (auto& it : ShadowMapData)
		{
			FSoftObjectPath Path(it.Key);
			Ar << Path;

			int32 ShadowMapType = (int32)it.Value->GetType();
			Ar << ShadowMapType;

			int32 SizeX = it.Value->GetSizeX();
			int32 SizeY = it.Value->GetSizeY();
			Ar << SizeX;
			Ar << SizeY;

			it.Value->Serialize(&Ar);
		}

	}	
}

#undef LOCTEXT_NAMESPACE