// Copyright 1998-2014 Epic Games, Inc. All Rights Reserved.

#include "MeshUtilitiesPrivate.h"
#include "StaticMeshResources.h"
#include "SkeletalMeshTypes.h"
#include "Landscape/LandscapeRender.h"
#include "MeshBuild.h"
#include "TessellationRendering.h"
#include "NvTriStrip.h"
#include "forsythtriangleorderoptimizer.h"
#include "ThirdParty/nvtesslib/inc/nvtess.h"
#include "SkeletalMeshTools.h"
#include "Landscape/LandscapeDataAccess.h"
#include "ImageUtils.h"
#include "MaterialExportUtils.h"
#include "Textures/TextureAtlas.h"

//@todo - implement required vector intrinsics for other implementations
#if PLATFORM_ENABLE_VECTORINTRINSICS
#include "kDOP.h"
#endif

/*------------------------------------------------------------------------------
	MeshUtilities module.
------------------------------------------------------------------------------*/

// The version string is a GUID. If you make a change to mesh utilities that
// causes meshes to be rebuilt you MUST generate a new GUID and replace this
// string with it.

#define MESH_UTILITIES_VER TEXT("359a039847e84730ba516769d0f19427")

DEFINE_LOG_CATEGORY_STATIC(LogMeshUtilities,Verbose,All);

//@todo - implement required vector intrinsics for other implementations
#if PLATFORM_ENABLE_VECTORINTRINSICS

class FMeshBuildDataProvider
{
public:

	/** Initialization constructor. */
	FMeshBuildDataProvider(
		const TkDOPTree<const FMeshBuildDataProvider,uint32>& InkDopTree):
		kDopTree(InkDopTree)
	{}

	// kDOP data provider interface.

	FORCEINLINE const TkDOPTree<const FMeshBuildDataProvider,uint32>& GetkDOPTree(void) const
	{
		return kDopTree;
	}

	FORCEINLINE const FMatrix& GetLocalToWorld(void) const
	{
		return FMatrix::Identity;
	}

	FORCEINLINE const FMatrix& GetWorldToLocal(void) const
	{
		return FMatrix::Identity;
	}

	FORCEINLINE FMatrix GetLocalToWorldTransposeAdjoint(void) const
	{
		return FMatrix::Identity;
	}

	FORCEINLINE float GetDeterminant(void) const
	{
		return 1.0f;
	}

private:

	const TkDOPTree<const FMeshBuildDataProvider,uint32>& kDopTree;
};

/** Generates unit length, stratified and uniformly distributed direction samples in a hemisphere. */
void GenerateStratifiedUniformHemisphereSamples(int32 NumThetaSteps, int32 NumPhiSteps, FRandomStream& RandomStream, TArray<FVector4>& Samples)
{
	Samples.Empty(NumThetaSteps * NumPhiSteps);
	for (int32 ThetaIndex = 0; ThetaIndex < NumThetaSteps; ThetaIndex++)
	{
		for (int32 PhiIndex = 0; PhiIndex < NumPhiSteps; PhiIndex++)
		{
			const float U1 = RandomStream.GetFraction();
			const float U2 = RandomStream.GetFraction();

			const float Fraction1 = (ThetaIndex + U1) / (float)NumThetaSteps;
			const float Fraction2 = (PhiIndex + U2) / (float)NumPhiSteps;

			const float R = FMath::Sqrt(1.0f - Fraction1 * Fraction1);

			const float Phi = 2.0f * (float)PI * Fraction2;
			// Convert to Cartesian
			Samples.Add(FVector4(FMath::Cos(Phi) * R, FMath::Sin(Phi) * R, Fraction1));
		}
	}
}

class FMeshDistanceFieldThreadRunnable : public FRunnable
{
private:
	FRunnableThread* Thread;

	// Readonly inputs
	TkDOPTree<const FMeshBuildDataProvider,uint32>& kDopTree;
	const TArray<FVector4>& SampleDirections;
	FBox VolumeBounds;
	FIntVector VolumeDimensions;
	float VolumeMaxDistance;

	volatile int32* SharedZIndex;
	volatile int32* NegativeAtBorder;

	// Output
	TArray<FFloat16>& OutDistanceFieldVolume;

	static int32 NextThreadIndex;

public:
	/** Initialization constructor. */
	FMeshDistanceFieldThreadRunnable(
		TkDOPTree<const FMeshBuildDataProvider,uint32>& InkDopTree, 
		const TArray<FVector4>& InSampleDirections,
		FBox InVolumeBounds,
		FIntVector InVolumeDimensions,
		float InVolumeMaxDistance,
		volatile int32* InSharedZIndex,
		volatile int32* InNegativeAtBorder,
		TArray<FFloat16>& DistanceFieldVolume)
		:
		kDopTree(InkDopTree),
		SampleDirections(InSampleDirections),
		VolumeBounds(InVolumeBounds),
		VolumeDimensions(InVolumeDimensions),
		VolumeMaxDistance(InVolumeMaxDistance),
		SharedZIndex(InSharedZIndex),
		NegativeAtBorder(InNegativeAtBorder),
		OutDistanceFieldVolume(DistanceFieldVolume)
	{
		Thread = FRunnableThread::Create(this, *FString::Printf(TEXT("MeshDistanceFieldThread%u"), NextThreadIndex), 0, TPri_Normal);
		NextThreadIndex++;
	}

	// FRunnable interface.
	virtual bool Init(void) { return true; }
	virtual void Exit(void) {}
	virtual void Stop(void) {}
	virtual uint32 Run(void);

	void WaitForCompletion()
	{
		Thread->WaitForCompletion();
	}
};

int32 FMeshDistanceFieldThreadRunnable::NextThreadIndex = 0;

uint32 FMeshDistanceFieldThreadRunnable::Run()
{
	int32 ZIndex = FPlatformAtomics::InterlockedAdd(SharedZIndex, 1);;
	FMeshBuildDataProvider kDOPDataProvider(kDopTree);

	while (ZIndex < VolumeDimensions.Z)
	{
		const FVector4 DistanceFieldVoxelSize(VolumeBounds.GetSize() / FVector(VolumeDimensions.X, VolumeDimensions.Y, VolumeDimensions.Z));

		for (int32 YIndex = 0; YIndex < VolumeDimensions.Y; YIndex++)
		{
			for (int32 XIndex = 0; XIndex < VolumeDimensions.X; XIndex++)
			{
				const FVector4 VoxelPosition = FVector4(XIndex + .5f, YIndex + .5f, ZIndex + .5f) * DistanceFieldVoxelSize + VolumeBounds.Min;
				const int32 Index = (ZIndex * VolumeDimensions.Y * VolumeDimensions.X + YIndex * VolumeDimensions.X + XIndex);

				float MinDistance = VolumeMaxDistance;
				int32 Hit = 0;
				int32 HitFront = 0;

				for (int32 SampleIndex = 0; SampleIndex < SampleDirections.Num(); SampleIndex++)
				{
					const FVector RayDirection = SampleDirections[SampleIndex];
					const FVector ReflectedRayDirection = RayDirection;

					//@todo - worth it anymore?
					if (FMath::LineBoxIntersection(VolumeBounds, VoxelPosition, VoxelPosition + ReflectedRayDirection * VolumeMaxDistance, ReflectedRayDirection, FVector(1.0f) / ReflectedRayDirection))
					{
						FkHitResult Result;

						TkDOPLineCollisionCheck<const FMeshBuildDataProvider,uint32> kDOPCheck(
							VoxelPosition,
							VoxelPosition + ReflectedRayDirection * VolumeMaxDistance,
							true,
							kDOPDataProvider,
							&Result);

						bool bHit = kDopTree.LineCheck(kDOPCheck);

						if (bHit)
						{
							Hit++;

							const FVector HitNormal = kDOPCheck.GetHitNormal();

							if (FVector::DotProduct(ReflectedRayDirection, HitNormal) < 0 
								// MaterialIndex on the build triangles was set to 1 if two-sided, or 0 if one-sided
								|| kDOPCheck.Result->Item != 0)
							{
								HitFront++;
							}

							const float CurrentDistance = VolumeMaxDistance * Result.Time;

							if (CurrentDistance < MinDistance)
							{
								MinDistance = CurrentDistance;
							}
						}
					}
				}

				// Consider this voxel 'outside' an object if more than 50% of the rays hit front faces
				MinDistance *= (Hit == 0 || HitFront > Hit * .5f) ? 1 : -1;

				const float VolumeSpaceDistance = MinDistance / VolumeBounds.GetExtent().GetMax();

				if (MinDistance < 0 && 
					(XIndex == 0 || XIndex == VolumeDimensions.X - 1 || 
						YIndex == 0 || YIndex == VolumeDimensions.Y - 1 || 
						ZIndex == 0 || ZIndex == VolumeDimensions.Z - 1))
				{
					*NegativeAtBorder = 1;
				}

				OutDistanceFieldVolume[Index] = FFloat16(VolumeSpaceDistance);
			}
		}

		ZIndex = FPlatformAtomics::InterlockedAdd(SharedZIndex, 1);
	}

	return 0;
}

static void GenerateSignedDistanceFieldVolumeData(
	FStaticMeshLODResources& LODModel,
	const TArray<UMaterialInterface*>& Materials,
	const FBoxSphereBounds& Bounds,
	float DistanceFieldResolutionScale)
{
	static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.AllowMeshDistanceFieldRepresentations"));

	if (DistanceFieldResolutionScale > 0 
		&& CVar 
		&& CVar->GetValueOnGameThread() != 0)
	{
		const FPositionVertexBuffer& PositionVertexBuffer = LODModel.PositionVertexBuffer;
		FIndexArrayView Indices = LODModel.IndexBuffer.GetArrayView();
		FDistanceFieldVolumeData& OutData = LODModel.DistanceFieldData;

		TArray<bool> CachedTwoSided;
		TArray<bool> CachedOpaqueOrMasked;

		CachedTwoSided.Empty(Materials.Num());
		CachedTwoSided.AddZeroed(Materials.Num());

		CachedOpaqueOrMasked.Empty(Materials.Num());
		CachedOpaqueOrMasked.AddZeroed(Materials.Num());

		for (int32 MaterialIndex = 0; MaterialIndex < Materials.Num(); MaterialIndex++)
		{
			UMaterialInterface* Material = Materials[MaterialIndex];

			if (Material)
			{
				CachedTwoSided[MaterialIndex] = Material->IsTwoSided();
				CachedOpaqueOrMasked[MaterialIndex] = !IsTranslucentBlendMode(Material->GetBlendMode());
			}
			else
			{
				// Default material properties
				CachedOpaqueOrMasked[MaterialIndex] = true;
			}
		}

		TArray<FkDOPBuildCollisionTriangle<uint32> > BuildTriangles;

		for (int32 i = 0; i < Indices.Num(); i += 3)
		{
			const FVector V0 = PositionVertexBuffer.VertexPosition(Indices[i + 0]);
			const FVector V1 = PositionVertexBuffer.VertexPosition(Indices[i + 1]);
			const FVector V2 = PositionVertexBuffer.VertexPosition(Indices[i + 2]);

			const FVector LocalNormal = ((V1 - V2) ^ (V0 - V2)).SafeNormal();

			// No degenerates
			if (LocalNormal.IsUnit())
			{
				uint32 StoreAsTwoSided = 0;
				bool bTriangleIsOpaqueOrMasked = false;

				for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
				{
					const FStaticMeshSection& Section = LODModel.Sections[SectionIndex];

					if ((uint32)i >= Section.FirstIndex && (uint32)i < Section.FirstIndex + Section.NumTriangles * 3)
					{
						if (CachedTwoSided.IsValidIndex(Section.MaterialIndex))
						{
							StoreAsTwoSided = CachedTwoSided[Section.MaterialIndex] ? 1 : 0;
						}

						if (CachedOpaqueOrMasked.IsValidIndex(Section.MaterialIndex))
						{
							bTriangleIsOpaqueOrMasked = CachedOpaqueOrMasked[Section.MaterialIndex];
						}
						
						break;
					}
				}

				if (bTriangleIsOpaqueOrMasked)
				{
					BuildTriangles.Add(FkDOPBuildCollisionTriangle<uint32>(
						StoreAsTwoSided, 
						V0,
						V1,
						V2));
				}
			}
		}

		TkDOPTree<const FMeshBuildDataProvider,uint32> kDopTree;
		kDopTree.Build(BuildTriangles);

		//@todo - project setting
		const int32 NumVoxelDistanceSamples = 1200;
		TArray<FVector4> SampleDirections;
		const int32 NumThetaSteps = FMath::TruncToInt(FMath::Sqrt(NumVoxelDistanceSamples / (2.0f * (float)PI)));
		const int32 NumPhiSteps = FMath::TruncToInt(NumThetaSteps * (float)PI);
		FRandomStream RandomStream(0);
		GenerateStratifiedUniformHemisphereSamples(NumThetaSteps, NumPhiSteps, RandomStream, SampleDirections);
		TArray<FVector4> OtherHemisphereSamples;
		GenerateStratifiedUniformHemisphereSamples(NumThetaSteps, NumPhiSteps, RandomStream, OtherHemisphereSamples);

		for (int32 i = 0; i < OtherHemisphereSamples.Num(); i++)
		{
			FVector4 Sample = OtherHemisphereSamples[i];
			Sample.Z *= -1;
			SampleDirections.Add(Sample);
		}

		// Meshes with explicit artist-specified scale can go higher
		//@todo - project setting
		const int32 MaxNumVoxelsOneDim = DistanceFieldResolutionScale <= 1 ? 64 : 128;
		const int32 MinNumVoxelsOneDim = 8;

		//@todo - project setting
		const float NumVoxelsPerLocalSpaceUnit = .1f * DistanceFieldResolutionScale;
		FBox MeshBounds(Bounds.GetBox());

		{
			const float MaxOriginalExtent = MeshBounds.GetExtent().GetMax();
			// Expand so that the edges of the volume are guaranteed to be outside of the mesh
			const FVector NewExtent(MeshBounds.GetExtent() + FVector(.2f * MaxOriginalExtent));
			FBox DistanceFieldVolumeBounds = FBox(MeshBounds.GetCenter() - NewExtent, MeshBounds.GetCenter() + NewExtent);
			const float DistanceFieldVolumeMaxDistance = DistanceFieldVolumeBounds.GetExtent().Size();

			const FVector DesiredDimensions(DistanceFieldVolumeBounds.GetSize() * FVector(NumVoxelsPerLocalSpaceUnit));

			const FIntVector VolumeDimensions(
				FMath::Clamp(FMath::TruncToInt(DesiredDimensions.X), MinNumVoxelsOneDim, MaxNumVoxelsOneDim), 
				FMath::Clamp(FMath::TruncToInt(DesiredDimensions.Y), MinNumVoxelsOneDim, MaxNumVoxelsOneDim),
				FMath::Clamp(FMath::TruncToInt(DesiredDimensions.Z), MinNumVoxelsOneDim, MaxNumVoxelsOneDim));

			OutData.Size = VolumeDimensions;
			OutData.LocalBoundingBox = DistanceFieldVolumeBounds;
			OutData.DistanceFieldVolume.AddZeroed(VolumeDimensions.X * VolumeDimensions.Y * VolumeDimensions.Z);

			UE_LOG(LogMeshUtilities,Log,TEXT("Beginning build of mesh - %ux%ux%u distance field, %u triangles"), 
				VolumeDimensions.X, 
				VolumeDimensions.Y, 
				VolumeDimensions.Z, 
				Indices.Num() / 3);

			const int32 NumThreads = FMath::Max<int32>(FPlatformMisc::NumberOfCoresIncludingHyperthreads() - 2, 1);
			TArray<FMeshDistanceFieldThreadRunnable*> Threads;

			volatile int32 SharedVolumeZIndex = 0;
			volatile int32 NegativeAtBorder = 0;

			for (int32 ThreadIndex = 0; ThreadIndex < NumThreads; ThreadIndex++)
			{
				Threads.Add(new FMeshDistanceFieldThreadRunnable(
					kDopTree,
					SampleDirections,
					DistanceFieldVolumeBounds,
					VolumeDimensions,
					DistanceFieldVolumeMaxDistance,
					&SharedVolumeZIndex,
					&NegativeAtBorder,
					OutData.DistanceFieldVolume));
			}

			for (int32 ThreadIndex = 0; ThreadIndex < NumThreads; ThreadIndex++)
			{
				Threads[ThreadIndex]->WaitForCompletion();
				delete Threads[ThreadIndex];
			}

			OutData.bMeshWasClosed = NegativeAtBorder == 0;

			// Toss distance field if mesh was not closed
			if (NegativeAtBorder != 0)
			{
				OutData.Size = FIntVector(0, 0, 0);
				OutData.DistanceFieldVolume.Empty();

				UE_LOG(LogMeshUtilities,Log,TEXT("Discarded distance field as mesh was not closed!  Assign a two-sided material to fix."));
			}
		}
	}
}

#else

static void GenerateSignedDistanceFieldVolumeData(
	FStaticMeshLODResources& LODModel,
	const TArray<UMaterialInterface*>& Materials,
	const FBoxSphereBounds& Bounds,
	float DistanceFieldResolutionScale)
{
	static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.AllowMeshDistanceFieldRepresentations"));

	if (DistanceFieldResolutionScale > 0 
		&& CVar 
		&& CVar->GetValueOnGameThread() != 0)
	{
		UE_LOG(LogMeshUtilities,Error,TEXT("Couldn't generate distance field for mesh, platform is missing required Vector intrinsics."));
	}
}

#endif

class FMeshUtilities : public IMeshUtilities
{
public:
	/** Default constructor. */
	FMeshUtilities()
		: MeshReduction(NULL)
		, MeshMerging(NULL)
	{
	}

private:
	/** Cached pointer to the mesh reduction interface. */
	IMeshReduction* MeshReduction;
	/** Cached pointer to the mesh merging interface. */
	IMeshMerging* MeshMerging;
	/** Cached version string. */
	FString VersionString;
	/** True if Simplygon is being used for mesh reduction. */
	bool bUsingSimplygon;
	/** True if NvTriStrip is being used for tri order optimization. */
	bool bUsingNvTriStrip;
	// IMeshUtilities interface.
	virtual const FString& GetVersionString() const override
	{
		return VersionString;
	}
	virtual bool BuildStaticMesh(
		FStaticMeshRenderData& OutRenderData,
		TArray<FStaticMeshSourceModel>& SourceModels,
		const TArray<UMaterialInterface*>& Materials,
		const FStaticMeshLODGroup& LODGroup
		) override;

	virtual bool BuildSkeletalMesh( FStaticLODModel& LODModel, const FReferenceSkeleton& RefSkeleton, const TArray<FVertInfluence>& Influences, const TArray<FMeshWedge>& Wedges, const TArray<FMeshFace>& Faces, const TArray<FVector>& Points, const TArray<int32>& PointToOriginalMap, bool bKeepOverlappingVertices = false, bool bComputeNormals = true, bool bComputeTangents = true );

	virtual bool GenerateUVs(
		FRawMesh& RawMesh,
		uint32 TexCoordIndex,
		float MinChartSpacingPercent,
		float BorderSpacingPercent,
		bool bUseMaxStretch,
		const TArray< int32 >* InFalseEdgeIndices,
		uint32& MaxCharts,
		float& MaxDesiredStretch,
		FText& OutError
		) override;

	virtual bool LayoutUVs(FRawMesh& RawMesh, uint32 TextureResolution, uint32 TexCoordIndex, FText& OutError) override;
	virtual IMeshReduction* GetMeshReductionInterface() override;
	virtual IMeshMerging* GetMeshMergingInterface() override;
	virtual void CacheOptimizeIndexBuffer(TArray<uint16>& Indices) override;
	virtual void CacheOptimizeIndexBuffer(TArray<uint32>& Indices) override;
	void CacheOptimizeVertexAndIndexBuffer(TArray<FStaticMeshBuildVertex>& Vertices,TArray<TArray<uint32> >& PerSectionIndices,TArray<int32>& WedgeMap);
	
	virtual void BuildSkeletalAdjacencyIndexBuffer(
		const TArray<FSoftSkinVertex>& VertexBuffer,
		const uint32 TexCoordCount,
		const TArray<uint32>& Indices,
		TArray<uint32>& OutPnAenIndices
		) override;

	virtual void CalcBoneVertInfos(USkeletalMesh* SkeletalMesh, TArray<FBoneVertInfo>& Infos, bool bOnlyDominant) override;

	/**
	 * Builds a renderable skeletal mesh LOD model. Note that the array of chunks
	 * will be destroyed during this process!
	 * @param LODModel				Upon return contains a renderable skeletal mesh LOD model.
	 * @param RefSkeleton			The reference skeleton associated with the model.
	 * @param Chunks				Skinned mesh chunks from which to build the renderable model.
	 * @param PointToOriginalMap	Maps a vertex's RawPointIdx to its index at import time.
	 */
	void BuildSkeletalModelFromChunks(FStaticLODModel& LODModel,const FReferenceSkeleton& RefSkeleton,TArray<FSkinnedMeshChunk*>& Chunks,const TArray<int32>& PointToOriginalMap);

	// IModuleInterface interface.
	virtual void StartupModule() override;
	virtual void ShutdownModule() override;

	virtual void MergeActors(
		const TArray<AActor*>& SourceActors,
		const FMeshMergingSettings& InSettings,
		const FString& PackageName,
		TArray<UObject*>& 
		OutAssetsToSync, 
		FVector& OutMergedActorLocation) const override;
	
	virtual void CreateProxyMesh( 
		const TArray<AActor*>& Actors, 
		const struct FMeshProxySettings& InProxySettings,
		UPackage* InOuter,
		const FString& ProxyBasePackageName,
		TArray<UObject*>& OutAssetsToSync,
		FVector& OutProxyLocation
		) override;
	
	bool ConstructRawMesh(
		UStaticMeshComponent* MeshComponent, 
		FRawMesh& OutRawMesh, 
		TArray<UMaterialInterface*>& OutUniqueMaterials,
		TArray<int32>& OutGlobalMaterialIndices
		) const;
};

IMPLEMENT_MODULE(FMeshUtilities, MeshUtilities);

/*------------------------------------------------------------------------------
	NVTriStrip for cache optimizing index buffers.
------------------------------------------------------------------------------*/

namespace NvTriStrip
{
	/**
	 * Converts 16 bit indices to 32 bit prior to passing them into the real GenerateStrips util method
	 */
	void GenerateStrips(
		const uint8* Indices,
		bool Is32Bit,
		const uint32 NumIndices,
		PrimitiveGroup** PrimGroups,
		uint32* NumGroups
		)
	{
		if (Is32Bit)
		{
			GenerateStrips((uint32*)Indices, NumIndices, PrimGroups, NumGroups);
		}
		else
		{
			// convert to 32 bit
			uint32 Idx;
			TArray<uint32> NewIndices;
			NewIndices.AddUninitialized(NumIndices);
			for (Idx = 0; Idx < NumIndices; ++Idx)
			{
				NewIndices[Idx] = ((uint16*)Indices)[Idx];
			}
			GenerateStrips(NewIndices.GetData(), NumIndices, PrimGroups, NumGroups);
		}

	}

	/**
	 * Orders a triangle list for better vertex cache coherency.
	 *
	 * *** WARNING: This is safe to call for multiple threads IF AND ONLY IF all
	 * threads call SetListsOnly(true) and SetCacheSize(CACHESIZE_GEFORCE3). If
	 * NvTriStrip is ever used with different settings the library will need
	 * some modifications to be thread-safe. ***
	 */
	template<typename IndexDataType, typename Allocator>
	void CacheOptimizeIndexBuffer(TArray<IndexDataType,Allocator>& Indices)
	{
		static_assert(sizeof(IndexDataType) == 2 || sizeof(IndexDataType) == 4, "Indices must be short or int.");

		PrimitiveGroup*	PrimitiveGroups = NULL;
		uint32			NumPrimitiveGroups = 0;
		bool Is32Bit = sizeof(IndexDataType) == 4;

		SetListsOnly(true);
		SetCacheSize(CACHESIZE_GEFORCE3);

		GenerateStrips((uint8*)Indices.GetTypedData(),Is32Bit,Indices.Num(),&PrimitiveGroups,&NumPrimitiveGroups);

		Indices.Empty();
		Indices.AddUninitialized(PrimitiveGroups->numIndices);
	
		if( Is32Bit )
		{
			FMemory::Memcpy(Indices.GetTypedData(),PrimitiveGroups->indices,Indices.Num() * sizeof(IndexDataType));
		}
		else
		{
			for( uint32 I = 0; I < PrimitiveGroups->numIndices; ++I )
			{
				Indices[I] = (uint16)PrimitiveGroups->indices[I];
			}
		}

		delete [] PrimitiveGroups;
	}
}

/*------------------------------------------------------------------------------
	Forsyth algorithm for cache optimizing index buffers.
------------------------------------------------------------------------------*/

namespace Forsyth
{
	/**
	 * Converts 16 bit indices to 32 bit prior to passing them into the real OptimizeFaces util method
	 */
	void OptimizeFaces(
		const uint8* Indices,
		bool Is32Bit,
		const uint32 NumIndices,
		uint32 NumVertices,
		uint32* OutIndices,
		uint16 CacheSize
		)
	{
		if (Is32Bit)
		{
			OptimizeFaces((uint32*)Indices, NumIndices, NumVertices, OutIndices, CacheSize);
		}
		else
		{
			// convert to 32 bit
			uint32 Idx;
			TArray<uint32> NewIndices;
			NewIndices.AddUninitialized(NumIndices);
			for (Idx = 0; Idx < NumIndices; ++Idx)
			{
				NewIndices[Idx] = ((uint16*)Indices)[Idx];
			}
			OptimizeFaces(NewIndices.GetData(),NumIndices, NumVertices, OutIndices, CacheSize);
		}

	}

	/**
	 * Orders a triangle list for better vertex cache coherency.
	 */
	template<typename IndexDataType, typename Allocator>
	void CacheOptimizeIndexBuffer(TArray<IndexDataType,Allocator>& Indices)
	{
		static_assert(sizeof(IndexDataType) == 2 || sizeof(IndexDataType) == 4, "Indices must be short or int.");
		bool Is32Bit = sizeof(IndexDataType) == 4;

		// Count the number of vertices
		uint32 NumVertices = 0;
		for(int32 Index = 0; Index < Indices.Num(); ++Index)
		{
			if(Indices[Index] > NumVertices)
			{
				NumVertices = Indices[Index];
			}
		}
		NumVertices += 1;

		TArray<uint32> OptimizedIndices;
		OptimizedIndices.AddUninitialized(Indices.Num());
		uint16 CacheSize = 32;
		OptimizeFaces((uint8*)Indices.GetData(),Is32Bit,Indices.Num(),NumVertices, OptimizedIndices.GetData(), CacheSize);

		if( Is32Bit )
		{
			FMemory::Memcpy(Indices.GetTypedData(),OptimizedIndices.GetTypedData(),Indices.Num() * sizeof(IndexDataType));
		}
		else
		{
			for( int32 I = 0; I < OptimizedIndices.Num(); ++I )
			{
				Indices[I] = (uint16)OptimizedIndices[I];
			}
		}
	}
}

void FMeshUtilities::CacheOptimizeIndexBuffer(TArray<uint16>& Indices)
{
	if(bUsingNvTriStrip)
	{
		NvTriStrip::CacheOptimizeIndexBuffer(Indices);
	}
	else
	{
		Forsyth::CacheOptimizeIndexBuffer(Indices);
	}
}

void FMeshUtilities::CacheOptimizeIndexBuffer(TArray<uint32>& Indices)
{
	if(bUsingNvTriStrip)
	{
		NvTriStrip::CacheOptimizeIndexBuffer(Indices);
	}
	else
	{
		Forsyth::CacheOptimizeIndexBuffer(Indices);
	}
}

/*------------------------------------------------------------------------------
	NVTessLib for computing adjacency used for tessellation.
------------------------------------------------------------------------------*/

/**
 * Provides static mesh render data to the NVIDIA tessellation library.
 */
class FStaticMeshNvRenderBuffer : public nv::RenderBuffer
{
public:

	/** Construct from static mesh render buffers. */
	FStaticMeshNvRenderBuffer(
		const FPositionVertexBuffer& InPositionVertexBuffer,
		const FStaticMeshVertexBuffer& InVertexBuffer,
		const TArray<uint32>& Indices )
		: PositionVertexBuffer( InPositionVertexBuffer )
		, VertexBuffer( InVertexBuffer )
	{
		check( PositionVertexBuffer.GetNumVertices() == VertexBuffer.GetNumVertices() );
		mIb = new nv::IndexBuffer( (void*)Indices.GetTypedData(), nv::IBT_U32, Indices.Num(), false );
	}

	/** Retrieve the position and first texture coordinate of the specified index. */
	virtual nv::Vertex getVertex( unsigned int Index ) const
	{
		nv::Vertex Vertex;

		check( Index < PositionVertexBuffer.GetNumVertices() );

		const FVector& Position = PositionVertexBuffer.VertexPosition( Index );
		Vertex.pos.x = Position.X;
		Vertex.pos.y = Position.Y;
		Vertex.pos.z = Position.Z;

		if( VertexBuffer.GetNumTexCoords() )
		{
			const FVector2D UV = VertexBuffer.GetVertexUV( Index, 0 );
			Vertex.uv.x = UV.X;
			Vertex.uv.y = UV.Y;
		}
		else
		{
			Vertex.uv.x = 0.0f;
			Vertex.uv.y = 0.0f;
		}

		return Vertex;
	}

private:

	/** The position vertex buffer for the static mesh. */
	const FPositionVertexBuffer& PositionVertexBuffer;

	/** The vertex buffer for the static mesh. */
	const FStaticMeshVertexBuffer& VertexBuffer;

	/** Copying is forbidden. */
	FStaticMeshNvRenderBuffer( const FStaticMeshNvRenderBuffer& ); 
	FStaticMeshNvRenderBuffer& operator=( const FStaticMeshNvRenderBuffer& );
};

/**
 * Provides skeletal mesh render data to the NVIDIA tessellation library.
 */
class FSkeletalMeshNvRenderBuffer : public nv::RenderBuffer
{
public:

	/** Construct from static mesh render buffers. */
	FSkeletalMeshNvRenderBuffer( 
		const TArray<FSoftSkinVertex>& InVertexBuffer,
		const uint32 InTexCoordCount,
		const TArray<uint32>& Indices )
		: VertexBuffer( InVertexBuffer )
		, TexCoordCount( InTexCoordCount )
	{
		mIb = new nv::IndexBuffer( (void*)Indices.GetTypedData(), nv::IBT_U32, Indices.Num(), false );
	}

	/** Retrieve the position and first texture coordinate of the specified index. */
	virtual nv::Vertex getVertex( unsigned int Index ) const
	{
		nv::Vertex Vertex;

		check( Index < (unsigned int)VertexBuffer.Num() );

		const FSoftSkinVertex& SrcVertex = VertexBuffer[ Index ];

		Vertex.pos.x = SrcVertex.Position.X;
		Vertex.pos.y = SrcVertex.Position.Y;
		Vertex.pos.z = SrcVertex.Position.Z;

		if( TexCoordCount > 0 )
		{
			Vertex.uv.x = SrcVertex.UVs[0].X;
			Vertex.uv.y = SrcVertex.UVs[0].Y;
		}
		else
		{
			Vertex.uv.x = 0.0f;
			Vertex.uv.y = 0.0f;
		}

		return Vertex;
	}

private:
	/** The vertex buffer for the skeletal mesh. */
	const TArray<FSoftSkinVertex>& VertexBuffer;
	const uint32 TexCoordCount;

	/** Copying is forbidden. */
	FSkeletalMeshNvRenderBuffer(const FSkeletalMeshNvRenderBuffer&); 
	FSkeletalMeshNvRenderBuffer& operator=(const FSkeletalMeshNvRenderBuffer&);
};

static void BuildStaticAdjacencyIndexBuffer(
	const FPositionVertexBuffer& PositionVertexBuffer,
	const FStaticMeshVertexBuffer& VertexBuffer,
	const TArray<uint32>& Indices,
	TArray<uint32>& OutPnAenIndices
	)
{
	if ( Indices.Num() )
	{
		FStaticMeshNvRenderBuffer StaticMeshRenderBuffer( PositionVertexBuffer, VertexBuffer, Indices );
		nv::IndexBuffer* PnAENIndexBuffer = nv::tess::buildTessellationBuffer( &StaticMeshRenderBuffer, nv::DBM_PnAenDominantCorner, true );
		check( PnAENIndexBuffer );
		const int32 IndexCount = (int32)PnAENIndexBuffer->getLength();
		OutPnAenIndices.Empty( IndexCount );
		OutPnAenIndices.AddUninitialized( IndexCount );
		for ( int32 Index = 0; Index < IndexCount; ++Index )
		{
			OutPnAenIndices[ Index ] = (*PnAENIndexBuffer)[Index];
		}
		delete PnAENIndexBuffer;
	}
	else
	{
		OutPnAenIndices.Empty();
	}
}

void FMeshUtilities::BuildSkeletalAdjacencyIndexBuffer(
	const TArray<FSoftSkinVertex>& VertexBuffer,
	const uint32 TexCoordCount,
	const TArray<uint32>& Indices,
	TArray<uint32>& OutPnAenIndices
	)
{
	if ( Indices.Num() )
	{
		FSkeletalMeshNvRenderBuffer SkeletalMeshRenderBuffer( VertexBuffer, TexCoordCount, Indices );
		nv::IndexBuffer* PnAENIndexBuffer = nv::tess::buildTessellationBuffer( &SkeletalMeshRenderBuffer, nv::DBM_PnAenDominantCorner, true );
		check( PnAENIndexBuffer );
		const int32 IndexCount = (int32)PnAENIndexBuffer->getLength();
		OutPnAenIndices.Empty( IndexCount );
		OutPnAenIndices.AddUninitialized( IndexCount );
		for ( int32 Index = 0; Index < IndexCount; ++Index )
		{
			OutPnAenIndices[ Index ] = (*PnAENIndexBuffer)[Index];
		}
		delete PnAENIndexBuffer;
	}
	else
	{
		OutPnAenIndices.Empty();
	}
}

void FMeshUtilities::CalcBoneVertInfos(USkeletalMesh* SkeletalMesh, TArray<FBoneVertInfo>& Infos, bool bOnlyDominant)
{
	SkeletalMeshTools::CalcBoneVertInfos(SkeletalMesh,Infos,bOnlyDominant);
}

/**
 * Builds a renderable skeletal mesh LOD model. Note that the array of chunks
 * will be destroyed during this process!
 * @param LODModel				Upon return contains a renderable skeletal mesh LOD model.
 * @param RefSkeleton			The reference skeleton associated with the model.
 * @param Chunks				Skinned mesh chunks from which to build the renderable model.
 * @param PointToOriginalMap	Maps a vertex's RawPointIdx to its index at import time.
 */
void FMeshUtilities::BuildSkeletalModelFromChunks(FStaticLODModel& LODModel,const FReferenceSkeleton& RefSkeleton,TArray<FSkinnedMeshChunk*>& Chunks,const TArray<int32>& PointToOriginalMap)
{
#if WITH_EDITORONLY_DATA
	// Clear out any data currently held in the LOD model.
	LODModel.Sections.Empty();
	LODModel.Chunks.Empty();
	LODModel.NumVertices = 0;
	if (LODModel.MultiSizeIndexContainer.IsIndexBufferValid())
	{
		LODModel.MultiSizeIndexContainer.GetIndexBuffer()->Empty();
	}

	// Setup the section and chunk arrays on the model.
	for (int32 ChunkIndex = 0; ChunkIndex < Chunks.Num(); ++ChunkIndex)
	{
		FSkinnedMeshChunk* SrcChunk = Chunks[ChunkIndex];

		FSkelMeshSection& Section = *new(LODModel.Sections) FSkelMeshSection();
		Section.MaterialIndex = SrcChunk->MaterialIndex;
		Section.ChunkIndex = ChunkIndex;

		FSkelMeshChunk& Chunk = *new(LODModel.Chunks) FSkelMeshChunk();
		Exchange(Chunk.BoneMap,SrcChunk->BoneMap);

		// Update the active bone indices on the LOD model.
		for (int32 BoneIndex = 0; BoneIndex < Chunk.BoneMap.Num(); ++BoneIndex)
		{
			LODModel.ActiveBoneIndices.AddUnique(Chunk.BoneMap[BoneIndex]);
		}
	}

	// Reset 'final vertex to import vertex' map info
	LODModel.MeshToImportVertexMap.Empty();
	LODModel.MaxImportVertex = 0;

	// Keep track of index mapping to chunk vertex offsets
	TArray< TArray<uint32> > VertexIndexRemap;
	VertexIndexRemap.Empty(LODModel.Sections.Num());
	// Pack the chunk vertices into a single vertex buffer.
	TArray<uint32> RawPointIndices;	
	LODModel.NumVertices = 0;

	int32 PrevMaterialIndex = -1;
	int32 CurrentChunkBaseVertexIndex = -1; 	// base vertex index for all chunks of the same material
	int32 CurrentChunkVertexCount = -1; 		// total vertex count for all chunks of the same material
	int32 CurrentVertexIndex = 0; 			// current vertex index added to the index buffer for all chunks of the same material

	// rearrange the vert order to minimize the data fetched by the GPU
	for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
	{
		if (IsInGameThread())
		{
			GWarn->StatusUpdate(SectionIndex, LODModel.Sections.Num(), NSLOCTEXT("UnrealEd", "ProcessingSections", "Processing Sections"));
		}

		FSkinnedMeshChunk* SrcChunk = Chunks[SectionIndex];
		FSkelMeshSection& Section = LODModel.Sections[SectionIndex];
		TArray<FSoftSkinBuildVertex>& ChunkVertices = SrcChunk->Vertices;
		TArray<uint32>& ChunkIndices = SrcChunk->Indices;

		// Reorder the section index buffer for better vertex cache efficiency.
		CacheOptimizeIndexBuffer(ChunkIndices);

		// Calculate the number of triangles in the section.  Note that CacheOptimize may change the number of triangles in the index buffer!
		Section.NumTriangles = ChunkIndices.Num() / 3;
		TArray<FSoftSkinBuildVertex> OriginalVertices;
		Exchange(ChunkVertices,OriginalVertices);
		ChunkVertices.AddUninitialized(OriginalVertices.Num());

		TArray<int32> IndexCache;
		IndexCache.AddUninitialized(ChunkVertices.Num());
		FMemory::Memset(IndexCache.GetData(), INDEX_NONE, IndexCache.Num() * IndexCache.GetTypeSize());
		int32 NextAvailableIndex = 0;
		// Go through the indices and assign them new values that are coherent where possible
		for (int32 Index = 0; Index < ChunkIndices.Num(); Index++)
		{
			const int32 OriginalIndex = ChunkIndices[Index];
			const int32 CachedIndex = IndexCache[OriginalIndex];

			if (CachedIndex == INDEX_NONE)
			{
				// No new index has been allocated for this existing index, assign a new one
				ChunkIndices[Index] = NextAvailableIndex;
				// Mark what this index has been assigned to
				IndexCache[OriginalIndex] = NextAvailableIndex;
				NextAvailableIndex++;
			}
			else
			{
				// Reuse an existing index assignment
				ChunkIndices[Index] = CachedIndex;
			}
			// Reorder the vertices based on the new index assignment
			ChunkVertices[ChunkIndices[Index]] = OriginalVertices[OriginalIndex];
		}
	}

	// Build the arrays of rigid and soft vertices on the model's chunks.
	for(int32 SectionIndex = 0;SectionIndex < LODModel.Sections.Num();SectionIndex++)
	{
		FSkelMeshSection& Section = LODModel.Sections[SectionIndex];
		int32 ChunkIndex = Section.ChunkIndex;
		FSkelMeshChunk& Chunk = LODModel.Chunks[ChunkIndex]; 
		TArray<FSoftSkinBuildVertex>& ChunkVertices = Chunks[ChunkIndex]->Vertices;

		if( IsInGameThread() )
		{
			// Only update status if in the game thread.  When importing morph targets, this function can run in another thread
			GWarn->StatusUpdate( ChunkIndex, LODModel.Chunks.Num(), NSLOCTEXT("UnrealEd", "ProcessingChunks", "Processing Chunks") );
		}

		CurrentVertexIndex = 0;
		CurrentChunkVertexCount = 0;
		PrevMaterialIndex = Section.MaterialIndex;

		// Calculate the offset to this chunk's vertices in the vertex buffer.
		Chunk.BaseVertexIndex = CurrentChunkBaseVertexIndex = LODModel.NumVertices;

		// Update the size of the vertex buffer.
		LODModel.NumVertices += ChunkVertices.Num();

		// Separate the section's vertices into rigid and soft vertices.
		TArray<uint32>& ChunkVertexIndexRemap = *new(VertexIndexRemap) TArray<uint32>();
		ChunkVertexIndexRemap.AddUninitialized(ChunkVertices.Num());
		for(int32 VertexIndex = 0;VertexIndex < ChunkVertices.Num();VertexIndex++)
		{
			const FSoftSkinBuildVertex& SoftVertex = ChunkVertices[VertexIndex];
			if(SoftVertex.InfluenceWeights[1] == 0)
			{
				FRigidSkinVertex RigidVertex;
				RigidVertex.Position = SoftVertex.Position;
				RigidVertex.TangentX = SoftVertex.TangentX;
				RigidVertex.TangentY = SoftVertex.TangentY;
				RigidVertex.TangentZ = SoftVertex.TangentZ;
				FMemory::Memcpy( RigidVertex.UVs, SoftVertex.UVs, sizeof(FVector2D)*MAX_TEXCOORDS );
				RigidVertex.Color = SoftVertex.Color;
				RigidVertex.Bone = SoftVertex.InfluenceBones[0];
				Chunk.RigidVertices.Add(RigidVertex);
				ChunkVertexIndexRemap[VertexIndex] = (uint32)(Chunk.BaseVertexIndex + CurrentVertexIndex);
				CurrentVertexIndex++;
				// add the index to the original wedge point source of this vertex
				RawPointIndices.Add( SoftVertex.PointWedgeIdx );
				// Also remember import index
				const int32 RawVertIndex = PointToOriginalMap[SoftVertex.PointWedgeIdx];
				LODModel.MeshToImportVertexMap.Add(RawVertIndex);
				LODModel.MaxImportVertex = FMath::Max<float>(LODModel.MaxImportVertex, RawVertIndex);
			}
		}
		for(int32 VertexIndex = 0;VertexIndex < ChunkVertices.Num();VertexIndex++)
		{
			const FSoftSkinBuildVertex& SoftVertex = ChunkVertices[VertexIndex];
			if(SoftVertex.InfluenceWeights[1] > 0)
			{
				FSoftSkinVertex NewVertex;
				NewVertex.Position = SoftVertex.Position;
				NewVertex.TangentX = SoftVertex.TangentX;
				NewVertex.TangentY = SoftVertex.TangentY;
				NewVertex.TangentZ = SoftVertex.TangentZ;
				FMemory::Memcpy( NewVertex.UVs, SoftVertex.UVs, sizeof(FVector2D)*MAX_TEXCOORDS );
				NewVertex.Color = SoftVertex.Color;
				for (int32 i = 0; i < MAX_TOTAL_INFLUENCES; ++i)
				{
					NewVertex.InfluenceBones[i] = SoftVertex.InfluenceBones[i];
					NewVertex.InfluenceWeights[i] = SoftVertex.InfluenceWeights[i];
				}
				Chunk.SoftVertices.Add(NewVertex);
				ChunkVertexIndexRemap[VertexIndex] = (uint32)(Chunk.BaseVertexIndex + CurrentVertexIndex);
				CurrentVertexIndex++;
				// add the index to the original wedge point source of this vertex
				RawPointIndices.Add( SoftVertex.PointWedgeIdx );
				// Also remember import index
				const int32 RawVertIndex = PointToOriginalMap[SoftVertex.PointWedgeIdx];
				LODModel.MeshToImportVertexMap.Add(RawVertIndex);
				LODModel.MaxImportVertex = FMath::Max<float>(LODModel.MaxImportVertex, RawVertIndex);
			}
		}

		// update total num of verts added
		Chunk.NumRigidVertices = Chunk.RigidVertices.Num();
		Chunk.NumSoftVertices = Chunk.SoftVertices.Num();

		// update max bone influences
		Chunk.CalcMaxBoneInfluences();

		// Log info about the chunk.
		UE_LOG(LogSkeletalMesh, Log, TEXT("Chunk %u: %u rigid vertices, %u soft vertices, %u active bones"),
			ChunkIndex,
			Chunk.RigidVertices.Num(),
			Chunk.SoftVertices.Num(),
			Chunk.BoneMap.Num()
			);
	}

	// Copy raw point indices to LOD model.
	LODModel.RawPointIndices.RemoveBulkData();
	if( RawPointIndices.Num() )
	{
		LODModel.RawPointIndices.Lock(LOCK_READ_WRITE);
		void* Dest = LODModel.RawPointIndices.Realloc( RawPointIndices.Num() );
		FMemory::Memcpy( Dest, RawPointIndices.GetData(), LODModel.RawPointIndices.GetBulkDataSize() );
		LODModel.RawPointIndices.Unlock();
	}

#if DISALLOW_32BIT_INDICES
	LODModel.MultiSizeIndexContainer.CreateIndexBuffer(sizeof(uint16));
#else
	LODModel.MultiSizeIndexContainer.CreateIndexBuffer((LODModel.NumVertices < MAX_uint16)? sizeof(uint16): sizeof(uint32));
#endif

	// Finish building the sections.
	for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
	{
		FSkelMeshSection& Section = LODModel.Sections[SectionIndex];

		const TArray<uint32>& SectionIndices = Chunks[SectionIndex]->Indices;
		FRawStaticIndexBuffer16or32Interface* IndexBuffer = LODModel.MultiSizeIndexContainer.GetIndexBuffer();
		Section.BaseIndex = IndexBuffer->Num();
		const int32 NumIndices = SectionIndices.Num();
		const TArray<uint32>& SectionVertexIndexRemap = VertexIndexRemap[Section.ChunkIndex];
		for (int32 Index = 0; Index < NumIndices; Index++)
		{
			uint32 VertexIndex = SectionVertexIndexRemap[SectionIndices[Index]];
			IndexBuffer->AddItem(VertexIndex);
		}
	}

	// Free the skinned mesh chunks which are no longer needed.
	for (int32 i = 0; i < Chunks.Num(); ++i)
	{
		delete Chunks[i];
		Chunks[i] = NULL;
	}
	Chunks.Empty();

	// Build the adjacency index buffer used for tessellation.
	{
		TArray<FSoftSkinVertex> Vertices;
		LODModel.GetVertices( Vertices );

		FMultiSizeIndexContainerData IndexData;
		LODModel.MultiSizeIndexContainer.GetIndexBufferData( IndexData );

		FMultiSizeIndexContainerData AdjacencyIndexData;
		AdjacencyIndexData.DataTypeSize = IndexData.DataTypeSize;

		BuildSkeletalAdjacencyIndexBuffer( Vertices, LODModel.NumTexCoords, IndexData.Indices, AdjacencyIndexData.Indices );
		LODModel.AdjacencyMultiSizeIndexContainer.RebuildIndexBuffer( AdjacencyIndexData );
	}

	// Compute the required bones for this model.
	USkeletalMesh::CalculateRequiredBones(LODModel,RefSkeleton,NULL);
#endif // #if WITH_EDITORONLY_DATA
}

/*------------------------------------------------------------------------------
	Common functionality.
------------------------------------------------------------------------------*/

/** Helper struct for building acceleration structures. */
struct FIndexAndZ
{
	float Z;
	int32 Index;

	/** Default constructor. */
	FIndexAndZ() {}

	/** Initialization constructor. */
	FIndexAndZ(int32 InIndex, FVector V)
	{
		Z = 0.30f * V.X + 0.33f * V.Y + 0.37f * V.Z;
		Index = InIndex;
	}
};

/** Sorting function for vertex Z/index pairs. */
struct FCompareIndexAndZ
{
	FORCEINLINE bool operator()(FIndexAndZ const& A, FIndexAndZ const& B) const { return A.Z < B.Z; }
};

static int32 ComputeNumTexCoords(FRawMesh const& RawMesh, int32 MaxSupportedTexCoords)
{
	int32 NumWedges = RawMesh.WedgeIndices.Num();
	int32 NumTexCoords = 0;
	for (int32 TexCoordIndex = 0; TexCoordIndex < MAX_MESH_TEXTURE_COORDS; ++TexCoordIndex)
	{
		if (RawMesh.WedgeTexCoords[TexCoordIndex].Num() != NumWedges)
		{
			break;
		}
		NumTexCoords++;
	}
	return FMath::Min(NumTexCoords, MaxSupportedTexCoords);
}

/**
 * Returns true if the specified points are about equal
 */
inline bool PointsEqual(const FVector& V1,const FVector& V2, float ComparisonThreshold)
{
	if (FMath::Abs(V1.X - V2.X) > ComparisonThreshold
		|| FMath::Abs(V1.Y - V2.Y) > ComparisonThreshold
		|| FMath::Abs(V1.Z - V2.Z) > ComparisonThreshold)
	{
		return false;
	}
	return true;
}

inline bool UVsEqual(const FVector2D& UV1,const FVector2D& UV2)
{
	if(FMath::Abs(UV1.X - UV2.X) > (1.0f / 1024.0f))
		return false;

	if(FMath::Abs(UV1.Y - UV2.Y) > (1.0f / 1024.0f))
		return false;

	return true;
}

static inline FVector GetPositionForWedge(FRawMesh const& Mesh, int32 WedgeIndex)
{
	int32 VertexIndex = Mesh.WedgeIndices[WedgeIndex];
	return Mesh.VertexPositions[VertexIndex];
}

struct FMeshEdge
{
	int32	Vertices[2];
	int32	Faces[2];
};

/**
 * This helper class builds the edge list for a mesh. It uses a hash of vertex
 * positions to edges sharing that vertex to remove the n^2 searching of all
 * previously added edges. This class is templatized so it can be used with
 * either static mesh or skeletal mesh vertices
 */
template <class VertexClass> class TEdgeBuilder
{
protected:
	/**
	 * The list of indices to build the edge data from
	 */
	const TArray<uint32>& Indices;
	/**
	 * The array of verts for vertex position comparison
	 */
	const TArray<VertexClass>& Vertices;
	/**
	 * The array of edges to create
	 */
	TArray<FMeshEdge>& Edges;
	/**
	 * List of edges that start with a given vertex
	 */
	TMultiMap<FVector,FMeshEdge*> VertexToEdgeList;

	/**
	 * This function determines whether a given edge matches or not. It must be
	 * provided by derived classes since they have the specific information that
	 * this class doesn't know about (vertex info, influences, etc)
	 *
	 * @param Index1 The first index of the edge being checked
	 * @param Index2 The second index of the edge
	 * @param OtherEdge The edge to compare. Was found via the map
	 *
	 * @return true if the edge is a match, false otherwise
	 */
	virtual bool DoesEdgeMatch(int32 Index1,int32 Index2,FMeshEdge* OtherEdge) = 0;

	/**
	 * Searches the list of edges to see if this one matches an existing and
	 * returns a pointer to it if it does
	 *
	 * @param Index1 the first index to check for
	 * @param Index2 the second index to check for
	 *
	 * @return NULL if no edge was found, otherwise the edge that was found
	 */
	inline FMeshEdge* FindOppositeEdge(int32 Index1,int32 Index2)
	{
		FMeshEdge* Edge = NULL;
		TArray<FMeshEdge*> EdgeList;
		// Search the hash for a corresponding vertex
		VertexToEdgeList.MultiFind(Vertices[Index2].Position,EdgeList);
		// Now search through the array for a match or not
		for (int32 EdgeIndex = 0; EdgeIndex < EdgeList.Num() && Edge == NULL;
			EdgeIndex++)
		{
			FMeshEdge* OtherEdge = EdgeList[EdgeIndex];
			// See if this edge matches the passed in edge
			if (OtherEdge != NULL && DoesEdgeMatch(Index1,Index2,OtherEdge))
			{
				// We have a match
				Edge = OtherEdge;
			}
		}
		return Edge;
	}

	/**
	 * Updates an existing edge if found or adds the new edge to the list
	 *
	 * @param Index1 the first index in the edge
	 * @param Index2 the second index in the edge
	 * @param Triangle the triangle that this edge was found in
	 */
	inline void AddEdge(int32 Index1,int32 Index2,int32 Triangle)
	{
		// If this edge matches another then just fill the other triangle
		// otherwise add it
		FMeshEdge* OtherEdge = FindOppositeEdge(Index1,Index2);
		if (OtherEdge == NULL)
		{
			// Add a new edge to the array
			int32 EdgeIndex = Edges.AddZeroed();
			Edges[EdgeIndex].Vertices[0] = Index1;
			Edges[EdgeIndex].Vertices[1] = Index2;
			Edges[EdgeIndex].Faces[0] = Triangle;
			Edges[EdgeIndex].Faces[1] = -1;
			// Also add this edge to the hash for faster searches
			// NOTE: This relies on the array never being realloced!
			VertexToEdgeList.Add(Vertices[Index1].Position,&Edges[EdgeIndex]);
		}
		else
		{
			OtherEdge->Faces[1] = Triangle;
		}
	}

public:
	/**
	 * Initializes the values for the code that will build the mesh edge list
	 */
	TEdgeBuilder(const TArray<uint32>& InIndices,
		const TArray<VertexClass>& InVertices,
		TArray<FMeshEdge>& OutEdges) :
		Indices(InIndices), Vertices(InVertices), Edges(OutEdges)
	{
		// Presize the array so that there are no extra copies being done
		// when adding edges to it
		Edges.Empty(Indices.Num());
	}

	/**
	* Virtual dtor
	*/
	virtual ~TEdgeBuilder(){}


	/**
	 * Uses a hash of indices to edge lists so that it can avoid the n^2 search
	 * through the full edge list
	 */
	void FindEdges(void)
	{
		// @todo Handle something other than trilists when building edges
		int32 TriangleCount = Indices.Num() / 3;
		int32 EdgeCount = 0;
		// Work through all triangles building the edges
		for (int32 Triangle = 0; Triangle < TriangleCount; Triangle++)
		{
			// Determine the starting index
			int32 TriangleIndex = Triangle * 3;
			// Get the indices for the triangle
			int32 Index1 = Indices[TriangleIndex];
			int32 Index2 = Indices[TriangleIndex + 1];
			int32 Index3 = Indices[TriangleIndex + 2];
			// Add the first to second edge
			AddEdge(Index1,Index2,Triangle);
			// Now add the second to third
			AddEdge(Index2,Index3,Triangle);
			// Add the third to first edge
			AddEdge(Index3,Index1,Triangle);
		}
	}
};

/**
 * This is the static mesh specific version for finding edges
 */
class FStaticMeshEdgeBuilder : public TEdgeBuilder<FStaticMeshBuildVertex>
{
public:
	/**
	 * Constructor that passes all work to the parent class
	 */
	FStaticMeshEdgeBuilder(const TArray<uint32>& InIndices,
		const TArray<FStaticMeshBuildVertex>& InVertices,
		TArray<FMeshEdge>& OutEdges) :
		TEdgeBuilder<FStaticMeshBuildVertex>(InIndices,InVertices,OutEdges)
	{
	}

	/**
	 * This function determines whether a given edge matches or not for a static mesh
	 *
	 * @param Index1 The first index of the edge being checked
	 * @param Index2 The second index of the edge
	 * @param OtherEdge The edge to compare. Was found via the map
	 *
	 * @return true if the edge is a match, false otherwise
	 */
	bool DoesEdgeMatch(int32 Index1,int32 Index2,FMeshEdge* OtherEdge)
	{
		return Vertices[OtherEdge->Vertices[1]].Position == Vertices[Index1].Position &&
			OtherEdge->Faces[1] == -1;
	}
};

static void ComputeTriangleTangents(
	TArray<FVector>& TriangleTangentX,
	TArray<FVector>& TriangleTangentY,
	TArray<FVector>& TriangleTangentZ,
	FRawMesh const& RawMesh,
	float ComparisonThreshold
	)
{
	int32 NumTriangles = RawMesh.WedgeIndices.Num() / 3;
	TriangleTangentX.Empty(NumTriangles);
	TriangleTangentY.Empty(NumTriangles);
	TriangleTangentZ.Empty(NumTriangles);

	for (int32 TriangleIndex = 0;TriangleIndex < NumTriangles; TriangleIndex++)
	{
		int32 UVIndex = 0;

		FVector P[3];
		for (int32 i = 0; i < 3; ++i)
		{
			P[i] = GetPositionForWedge(RawMesh, TriangleIndex * 3 + i);
		}

		const FVector Normal = ((P[1] - P[2])^(P[0] - P[2])).SafeNormal(ComparisonThreshold);
		FMatrix	ParameterToLocal(
			FPlane(P[1].X - P[0].X, P[1].Y - P[0].Y, P[1].Z - P[0].Z, 0),
			FPlane(P[2].X - P[0].X, P[2].Y - P[0].Y, P[2].Z - P[0].Z, 0),
			FPlane(P[0].X,          P[0].Y,          P[0].Z,          0),
			FPlane(0,               0,               0,				  1)
			);

		FVector2D T1 = RawMesh.WedgeTexCoords[UVIndex][TriangleIndex * 3 + 0];
		FVector2D T2 = RawMesh.WedgeTexCoords[UVIndex][TriangleIndex * 3 + 1];
		FVector2D T3 = RawMesh.WedgeTexCoords[UVIndex][TriangleIndex * 3 + 2];
		FMatrix ParameterToTexture(
			FPlane(	T2.X - T1.X,	T2.Y - T1.Y,	0,	0	),
			FPlane(	T3.X - T1.X,	T3.Y - T1.Y,	0,	0	),
			FPlane(	T1.X,			T1.Y,			1,	0	),
			FPlane(	0,				0,				0,	1	)
			);

		// Use InverseSlow to catch singular matrices.  InverseSafe can miss this sometimes.
		const FMatrix TextureToLocal = ParameterToTexture.InverseSlow() * ParameterToLocal;

		TriangleTangentX.Add(TextureToLocal.TransformVector(FVector(1,0,0)).SafeNormal());
		TriangleTangentY.Add(TextureToLocal.TransformVector(FVector(0,1,0)).SafeNormal());
		TriangleTangentZ.Add(Normal);

		FVector::CreateOrthonormalBasis(
			TriangleTangentX[TriangleIndex],
			TriangleTangentY[TriangleIndex],
			TriangleTangentZ[TriangleIndex]
			);
	}

	check(TriangleTangentX.Num() == NumTriangles);
	check(TriangleTangentY.Num() == NumTriangles);
	check(TriangleTangentZ.Num() == NumTriangles);
}

/**
 * Create a table that maps the corner of each face to its overlapping corners.
 * @param OutOverlappingCorners - Maps a corner index to the indices of all overlapping corners.
 * @param RawMesh - The mesh for which to compute overlapping corners.
 */
static void FindOverlappingCorners(
	TMultiMap<int32,int32>& OutOverlappingCorners,
	FRawMesh const& RawMesh,
	float ComparisonThreshold
	)
{
	int32 NumWedges = RawMesh.WedgeIndices.Num();

	// Create a list of vertex Z/index pairs
	TArray<FIndexAndZ> VertIndexAndZ;
	VertIndexAndZ.Empty(NumWedges);
	for(int32 WedgeIndex = 0; WedgeIndex < NumWedges; WedgeIndex++)
	{
		new(VertIndexAndZ) FIndexAndZ(WedgeIndex, GetPositionForWedge(RawMesh, WedgeIndex));
	}

	// Sort the vertices by z value
	VertIndexAndZ.Sort(FCompareIndexAndZ());

	// Search for duplicates, quickly!
	for (int32 i = 0; i < VertIndexAndZ.Num(); i++)
	{
		// only need to search forward, since we add pairs both ways
		for (int32 j = i + 1; j < VertIndexAndZ.Num(); j++)
		{
			if (FMath::Abs(VertIndexAndZ[j].Z - VertIndexAndZ[i].Z) > THRESH_POINTS_ARE_SAME * 4.01f)
				break; // can't be any more dups

			FVector PositionA = GetPositionForWedge(RawMesh, VertIndexAndZ[i].Index);
			FVector PositionB = GetPositionForWedge(RawMesh, VertIndexAndZ[j].Index);

			if (PointsEqual(PositionA, PositionB, ComparisonThreshold))					
			{
				OutOverlappingCorners.Add(VertIndexAndZ[i].Index,VertIndexAndZ[j].Index);
				OutOverlappingCorners.Add(VertIndexAndZ[j].Index,VertIndexAndZ[i].Index);
			}
		}
	}
}

namespace ETangentOptions
{
	enum Type
	{
		None = 0,
		BlendOverlappingNormals = 0x1,
		IgnoreDegenerateTriangles = 0x2,
	};
};

/**
	* Smoothing group interpretation helper structure.
	*/
struct FFanFace
{
	int32 FaceIndex;
	int32 LinkedVertexIndex;
	bool bFilled;
	bool bBlendTangents;
	bool bBlendNormals;
};

static void ComputeTangents(
	FRawMesh& RawMesh,
	TMultiMap<int32,int32> const& OverlappingCorners,
	uint32 TangentOptions
	)
{
	bool bBlendOverlappingNormals = (TangentOptions & ETangentOptions::BlendOverlappingNormals) != 0;
	bool bIgnoreDegenerateTriangles = (TangentOptions & ETangentOptions::IgnoreDegenerateTriangles) != 0;
	float ComparisonThreshold = bIgnoreDegenerateTriangles ? THRESH_POINTS_ARE_SAME : 0.0f;

	// Compute per-triangle tangents.
	TArray<FVector> TriangleTangentX;
	TArray<FVector> TriangleTangentY;
	TArray<FVector> TriangleTangentZ;

	ComputeTriangleTangents(
		TriangleTangentX,
		TriangleTangentY,
		TriangleTangentZ,
		RawMesh,
		bIgnoreDegenerateTriangles ? SMALL_NUMBER : 0.0f
		);

	// Declare these out here to avoid reallocations.
	TArray<FFanFace> RelevantFacesForCorner[3];
	TArray<int32> AdjacentFaces;
	TArray<int32> DupVerts;

	int32 NumWedges = RawMesh.WedgeIndices.Num();
	int32 NumFaces = NumWedges / 3;

	// Allocate storage for tangents if none were provided.
	if (RawMesh.WedgeTangentX.Num() != NumWedges)
	{
		RawMesh.WedgeTangentX.Empty(NumWedges);
		RawMesh.WedgeTangentX.AddZeroed(NumWedges);
	}
	if (RawMesh.WedgeTangentY.Num() != NumWedges)
	{
		RawMesh.WedgeTangentY.Empty(NumWedges);
		RawMesh.WedgeTangentY.AddZeroed(NumWedges);
	}
	if (RawMesh.WedgeTangentZ.Num() != NumWedges)
	{
		RawMesh.WedgeTangentZ.Empty(NumWedges);
		RawMesh.WedgeTangentZ.AddZeroed(NumWedges);
	}

	for (int32 FaceIndex = 0; FaceIndex < NumFaces; FaceIndex++)
	{
		int32 WedgeOffset = FaceIndex * 3;
		FVector CornerPositions[3];
		FVector CornerTangentX[3];
		FVector CornerTangentY[3];
		FVector CornerTangentZ[3];

		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			CornerTangentX[CornerIndex] = FVector::ZeroVector;
			CornerTangentY[CornerIndex] = FVector::ZeroVector;
			CornerTangentZ[CornerIndex] = FVector::ZeroVector;
			CornerPositions[CornerIndex] = GetPositionForWedge(RawMesh, WedgeOffset + CornerIndex);
			RelevantFacesForCorner[CornerIndex].Reset();
		}

		// Don't process degenerate triangles.
		if (PointsEqual(CornerPositions[0],CornerPositions[1], ComparisonThreshold)
			|| PointsEqual(CornerPositions[0],CornerPositions[2], ComparisonThreshold)
			|| PointsEqual(CornerPositions[1],CornerPositions[2], ComparisonThreshold))
		{
			continue;
		}

		// No need to process triangles if tangents already exist.
		bool bCornerHasTangents[3] = {0};
		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			bCornerHasTangents[CornerIndex] = !RawMesh.WedgeTangentX[WedgeOffset + CornerIndex].IsZero()
				&& !RawMesh.WedgeTangentY[WedgeOffset + CornerIndex].IsZero()
				&& !RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex].IsZero();
		}
		if (bCornerHasTangents[0] && bCornerHasTangents[1] && bCornerHasTangents[2])
		{
			continue;
		}

		// Calculate smooth vertex normals.
		float Determinant = FVector::Triple(
			TriangleTangentX[FaceIndex],
			TriangleTangentY[FaceIndex],
			TriangleTangentZ[FaceIndex]
			);

		// Start building a list of faces adjacent to this face.
		AdjacentFaces.Reset();
		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			int32 ThisCornerIndex = WedgeOffset + CornerIndex;
			DupVerts.Reset();
			OverlappingCorners.MultiFind(ThisCornerIndex,DupVerts);
			DupVerts.Add(ThisCornerIndex); // I am a "dup" of myself
			for (int32 k = 0; k < DupVerts.Num(); k++)
			{
				AdjacentFaces.AddUnique(DupVerts[k] / 3);
			}
		}

		// We need to sort these here because the criteria for point equality is
		// exact, so we must ensure the exact same order for all dups.
		AdjacentFaces.Sort();

		// Process adjacent faces
		for (int32 AdjacentFaceIndex = 0; AdjacentFaceIndex < AdjacentFaces.Num(); AdjacentFaceIndex++)
		{
			int32 OtherFaceIndex = AdjacentFaces[AdjacentFaceIndex];
			for (int32 OurCornerIndex = 0; OurCornerIndex < 3; OurCornerIndex++)
			{
				if (bCornerHasTangents[OurCornerIndex])
					continue;

				FFanFace NewFanFace;
				int32 CommonIndexCount = 0;

				// Check for vertices in common.
				if (FaceIndex == OtherFaceIndex)
				{
					CommonIndexCount = 3;		
					NewFanFace.LinkedVertexIndex = OurCornerIndex;
				}
				else
				{
					// Check matching vertices against main vertex .
					for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
					{
						if (PointsEqual(
								CornerPositions[OurCornerIndex],
								GetPositionForWedge(RawMesh, OtherFaceIndex * 3 + OtherCornerIndex),
								ComparisonThreshold
								))
						{
							CommonIndexCount++;
							NewFanFace.LinkedVertexIndex = OtherCornerIndex;
						}
					}
				}

				// Add if connected by at least one point. Smoothing matches are considered later.
				if (CommonIndexCount > 0)
				{ 					
					NewFanFace.FaceIndex = OtherFaceIndex;
					NewFanFace.bFilled = (OtherFaceIndex == FaceIndex); // Starter face for smoothing floodfill.
					NewFanFace.bBlendTangents = NewFanFace.bFilled;
					NewFanFace.bBlendNormals = NewFanFace.bFilled;
					RelevantFacesForCorner[OurCornerIndex].Add(NewFanFace);
				}
			}
		}

		// Find true relevance of faces for a vertex normal by traversing
		// smoothing-group-compatible connected triangle fans around common vertices.
		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			if (bCornerHasTangents[CornerIndex])
				continue;

			int32 NewConnections;
			do
			{
				NewConnections = 0;
				for (int32 OtherFaceIdx=0; OtherFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); OtherFaceIdx++)
				{
					FFanFace& OtherFace = RelevantFacesForCorner[CornerIndex][OtherFaceIdx];
					// The vertex' own face is initially the only face with bFilled == true.
					if (OtherFace.bFilled)
					{				
						for (int32 NextFaceIndex = 0; NextFaceIndex < RelevantFacesForCorner[CornerIndex].Num(); NextFaceIndex++)
						{
							FFanFace& NextFace = RelevantFacesForCorner[CornerIndex][NextFaceIndex];
							if (!NextFace.bFilled) // && !NextFace.bBlendTangents)
							{
								if ((NextFaceIndex != OtherFaceIdx)
									&& (RawMesh.FaceSmoothingMasks[NextFace.FaceIndex] & RawMesh.FaceSmoothingMasks[OtherFace.FaceIndex]))
								{				
									int32 CommonVertices = 0;
									int32 CommonTangentVertices = 0;
									int32 CommonNormalVertices = 0;
									for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
									{											
										for (int32 NextCornerIndex = 0; NextCornerIndex < 3; NextCornerIndex++)
										{
											int32 NextVertexIndex = RawMesh.WedgeIndices[NextFace.FaceIndex * 3 + NextCornerIndex];
											int32 OtherVertexIndex = RawMesh.WedgeIndices[OtherFace.FaceIndex * 3 + OtherCornerIndex];
											if (PointsEqual(
													RawMesh.VertexPositions[NextVertexIndex],
													RawMesh.VertexPositions[OtherVertexIndex],
													ComparisonThreshold))
											{
												CommonVertices++;
												if (UVsEqual(
														RawMesh.WedgeTexCoords[0][NextFace.FaceIndex * 3 + NextCornerIndex],
														RawMesh.WedgeTexCoords[0][OtherFace.FaceIndex * 3 + OtherCornerIndex]))
												{
													CommonTangentVertices++;
												}
												if (bBlendOverlappingNormals
													|| NextVertexIndex == OtherVertexIndex)
												{
													CommonNormalVertices++;
												}
											}
										}										
									}
									// Flood fill faces with more than one common vertices which must be touching edges.
									if (CommonVertices > 1)
									{
										NextFace.bFilled = true;
										NextFace.bBlendNormals = (CommonNormalVertices > 1);
										NewConnections++;

										// Only blend tangents if there is no UV seam along the edge with this face.
										if (OtherFace.bBlendTangents && CommonTangentVertices > 1)
										{
											float OtherDeterminant = FVector::Triple(
												TriangleTangentX[NextFace.FaceIndex],
												TriangleTangentY[NextFace.FaceIndex],
												TriangleTangentZ[NextFace.FaceIndex]
												);
											if ((Determinant * OtherDeterminant) > 0.0f)
											{
												NextFace.bBlendTangents = true;
											}
										}
									}								
								}
							}
						}
					}
				}
			}
			while (NewConnections > 0);
		}
        

		// Vertex normal construction.
		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			if (bCornerHasTangents[CornerIndex])
			{
				CornerTangentX[CornerIndex] = RawMesh.WedgeTangentX[WedgeOffset + CornerIndex];
				CornerTangentY[CornerIndex] = RawMesh.WedgeTangentY[WedgeOffset + CornerIndex];
				CornerTangentZ[CornerIndex] = RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex];
			}
			else
			{
				for (int32 RelevantFaceIdx = 0; RelevantFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); RelevantFaceIdx++)
				{
					FFanFace const& RelevantFace = RelevantFacesForCorner[CornerIndex][RelevantFaceIdx];
					if (RelevantFace.bFilled)
					{
						int32 OtherFaceIndex = RelevantFace.FaceIndex;
						if (RelevantFace.bBlendTangents)
						{
							CornerTangentX[CornerIndex] += TriangleTangentX[OtherFaceIndex];
							CornerTangentY[CornerIndex] += TriangleTangentY[OtherFaceIndex];
						}
						if (RelevantFace.bBlendNormals)
						{
							CornerTangentZ[CornerIndex] += TriangleTangentZ[OtherFaceIndex];
						}
					}
				}
				if (!RawMesh.WedgeTangentX[WedgeOffset + CornerIndex].IsZero())
				{
					CornerTangentX[CornerIndex] = RawMesh.WedgeTangentX[WedgeOffset + CornerIndex];
				}
				if (!RawMesh.WedgeTangentY[WedgeOffset + CornerIndex].IsZero())
				{
					CornerTangentY[CornerIndex] = RawMesh.WedgeTangentY[WedgeOffset + CornerIndex];
				}
				if (!RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex].IsZero())
				{
					CornerTangentZ[CornerIndex] = RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex];
				}
			}
		}

		// Normalization.
		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			CornerTangentX[CornerIndex].Normalize();
			CornerTangentY[CornerIndex].Normalize();
			CornerTangentZ[CornerIndex].Normalize();

			// Gram-Schmidt orthogonalization
			CornerTangentY[CornerIndex] -= CornerTangentX[CornerIndex] * (CornerTangentX[CornerIndex] | CornerTangentY[CornerIndex]);
			CornerTangentY[CornerIndex].Normalize();

			CornerTangentX[CornerIndex] -= CornerTangentZ[CornerIndex] * (CornerTangentZ[CornerIndex] | CornerTangentX[CornerIndex]);
			CornerTangentX[CornerIndex].Normalize();
			CornerTangentY[CornerIndex] -= CornerTangentZ[CornerIndex] * (CornerTangentZ[CornerIndex] | CornerTangentY[CornerIndex]);
			CornerTangentY[CornerIndex].Normalize();
		}

		// Copy back to the mesh.
		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			RawMesh.WedgeTangentX[WedgeOffset + CornerIndex] = CornerTangentX[CornerIndex];
			RawMesh.WedgeTangentY[WedgeOffset + CornerIndex] = CornerTangentY[CornerIndex];
			RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex] = CornerTangentZ[CornerIndex];
		}
	}

	check(RawMesh.WedgeTangentX.Num() == NumWedges);
	check(RawMesh.WedgeTangentY.Num() == NumWedges);
	check(RawMesh.WedgeTangentZ.Num() == NumWedges);
}

static void ComputeStreamingTextureFactors(
	float* OutStreamingTextureFactors,
	float* OutMaxStreamingTextureFactor,
	const FRawMesh& Mesh,
	const FVector& BuildScale
	)
{
	int32 NumTexCoords = ComputeNumTexCoords(Mesh, MAX_STATIC_TEXCOORDS);
	int32 NumFaces = Mesh.WedgeIndices.Num() / 3;
	TArray<float> TexelRatios[MAX_STATIC_TEXCOORDS];
	float MaxStreamingTextureFactor = 0.0f;
	for (int32 FaceIndex = 0; FaceIndex < NumFaces; ++FaceIndex)
	{
		int32 Wedge0 = FaceIndex * 3 + 0;
		int32 Wedge1 = FaceIndex * 3 + 1;
		int32 Wedge2 = FaceIndex * 3 + 2;

		const FVector& Pos0 = Mesh.GetWedgePosition(Wedge0) * BuildScale;
		const FVector& Pos1 = Mesh.GetWedgePosition(Wedge1) * BuildScale;
		const FVector& Pos2 = Mesh.GetWedgePosition(Wedge2) * BuildScale;
		float	L1	= (Pos0 - Pos1).Size(),
				L2	= (Pos0 - Pos2).Size();

		for(int32 UVIndex = 0;UVIndex < NumTexCoords;UVIndex++)
		{
			FVector2D UV0 = Mesh.WedgeTexCoords[UVIndex][Wedge0];
			FVector2D UV1 = Mesh.WedgeTexCoords[UVIndex][Wedge1];
			FVector2D UV2 = Mesh.WedgeTexCoords[UVIndex][Wedge2];

			float	T1	= (UV0 - UV1).Size(),
					T2	= (UV0 - UV2).Size();

			if( FMath::Abs(T1 * T2) > FMath::Square(SMALL_NUMBER) )
			{
				const float TexelRatio = FMath::Max( L1 / T1, L2 / T2 );
				TexelRatios[UVIndex].Add( TexelRatio );

				// Update max texel ratio
				if( TexelRatio > MaxStreamingTextureFactor )
				{
					MaxStreamingTextureFactor = TexelRatio;
				}
			}
		}
	}

	for(int32 UVIndex = 0;UVIndex < MAX_STATIC_TEXCOORDS;UVIndex++)
	{
		OutStreamingTextureFactors[UVIndex] = 0.0f;
		if( TexelRatios[UVIndex].Num() )
		{
			// Disregard upper 75% of texel ratios.
			// This is to ignore backfacing surfaces or other non-visible surfaces that tend to map a small number of texels to a large surface.
			TexelRatios[UVIndex].Sort( TGreater<float>() );
			float TexelRatio = TexelRatios[UVIndex][ FMath::TruncToInt(TexelRatios[UVIndex].Num() * 0.75f) ];
			OutStreamingTextureFactors[UVIndex] = TexelRatio;
		}
	}
	*OutMaxStreamingTextureFactor = MaxStreamingTextureFactor;
}

static void BuildDepthOnlyIndexBuffer(
	TArray<uint32>& OutDepthIndices,
	const TArray<FStaticMeshBuildVertex>& InVertices,
	const TArray<uint32>& InIndices,
	const TArray<FStaticMeshSection>& InSections
	)
{
	int32 NumVertices = InVertices.Num();
	if (InIndices.Num() <= 0 || NumVertices <= 0)
	{
		OutDepthIndices.Empty();
		return;
	}

	// Create a mapping of index -> first overlapping index to accelerate the construction of the shadow index buffer.
	TArray<FIndexAndZ> VertIndexAndZ;
	VertIndexAndZ.Empty(NumVertices);
	for(int32 VertIndex = 0; VertIndex < NumVertices; VertIndex++)
	{
		new(VertIndexAndZ) FIndexAndZ(VertIndex, InVertices[VertIndex].Position);
	}
	VertIndexAndZ.Sort(FCompareIndexAndZ());

	// Setup the index map. 0xFFFFFFFF == not set.
	TArray<uint32> IndexMap;
	IndexMap.AddUninitialized(NumVertices);
	FMemory::Memset(IndexMap.GetData(),0xFF,NumVertices * sizeof(uint32));

	// Search for duplicates, quickly!
	for (int32 i = 0; i < VertIndexAndZ.Num(); i++)
	{
		uint32 SrcIndex = VertIndexAndZ[i].Index;
		float Z = VertIndexAndZ[i].Z;
		IndexMap[SrcIndex] = FMath::Min(IndexMap[SrcIndex], SrcIndex);

		// Search forward since we add pairs both ways.
		for (int32 j = i + 1; j < VertIndexAndZ.Num(); j++)
		{
			if (FMath::Abs(VertIndexAndZ[j].Z - Z) > THRESH_POINTS_ARE_SAME * 4.01f)
				break; // can't be any more dups

			uint32 OtherIndex = VertIndexAndZ[j].Index;
			if (PointsEqual(InVertices[SrcIndex].Position,InVertices[OtherIndex].Position,/*bUseEpsilonCompare=*/ true))					
			{
				IndexMap[SrcIndex] = FMath::Min(IndexMap[SrcIndex], OtherIndex);
				IndexMap[OtherIndex] = FMath::Min(IndexMap[OtherIndex], SrcIndex);
			}
		}
	}

	// Build the depth-only index buffer by remapping all indices to the first overlapping
	// vertex in the vertex buffer.
	OutDepthIndices.Empty();
	for (int32 SectionIndex = 0; SectionIndex < InSections.Num(); ++SectionIndex)
	{
		const FStaticMeshSection& Section = InSections[SectionIndex];
		int32 FirstIndex = Section.FirstIndex;
		int32 LastIndex = FirstIndex + Section.NumTriangles * 3;
		for (int32 SrcIndex = FirstIndex; SrcIndex < LastIndex; ++SrcIndex)
		{
			uint32 VertIndex = InIndices[SrcIndex];
			OutDepthIndices.Add(IndexMap[VertIndex]);
		}
	}
}

static float GetComparisonThreshold(FMeshBuildSettings const& BuildSettings)
{
	return BuildSettings.bRemoveDegenerates ? THRESH_POINTS_ARE_SAME : 0.0f;
}

/*------------------------------------------------------------------------------
	Static mesh building.
------------------------------------------------------------------------------*/

static FStaticMeshBuildVertex BuildStaticMeshVertex(FRawMesh const& RawMesh, int32 WedgeIndex, FVector BuildScale)
{
	FStaticMeshBuildVertex Vertex;
	Vertex.Position = GetPositionForWedge(RawMesh, WedgeIndex) * BuildScale;

	const FMatrix ScaleMatrix = FScaleMatrix( BuildScale ).Inverse().GetTransposed();	
	Vertex.TangentX = ScaleMatrix.TransformVector(RawMesh.WedgeTangentX[WedgeIndex]).SafeNormal();
	Vertex.TangentY = ScaleMatrix.TransformVector(RawMesh.WedgeTangentY[WedgeIndex]).SafeNormal();
	Vertex.TangentZ = ScaleMatrix.TransformVector(RawMesh.WedgeTangentZ[WedgeIndex]).SafeNormal();

	if (RawMesh.WedgeColors.IsValidIndex(WedgeIndex))
	{
		Vertex.Color = RawMesh.WedgeColors[WedgeIndex];
	}
	else
	{
		Vertex.Color = FColor::White;
	}

	int32 NumTexCoords = FMath::Min<int32>(MAX_MESH_TEXTURE_COORDS, MAX_STATIC_TEXCOORDS);
	for (int32 i = 0; i < NumTexCoords; ++i)
	{
		if (RawMesh.WedgeTexCoords[i].IsValidIndex(WedgeIndex))
		{
			Vertex.UVs[i] = RawMesh.WedgeTexCoords[i][WedgeIndex];
		}
		else
		{
			Vertex.UVs[i] = FVector2D(0.0f,0.0f);
		}
	}
	return Vertex;
}

static bool AreVerticesEqual(
	FStaticMeshBuildVertex const& A,
	FStaticMeshBuildVertex const& B,
	float ComparisonThreshold
	)
{
	if (!PointsEqual(A.Position, B.Position, ComparisonThreshold)
		|| !NormalsEqual(A.TangentX, B.TangentX)
		|| !NormalsEqual(A.TangentY, B.TangentY)
		|| !NormalsEqual(A.TangentZ, B.TangentZ)
		|| A.Color != B.Color)
	{
		return false;
	}

	// UVs
	for (int32 UVIndex = 0; UVIndex < MAX_STATIC_TEXCOORDS; UVIndex++)
	{
		if (!UVsEqual(A.UVs[UVIndex], B.UVs[UVIndex]))
		{
			return false;
		}
	}

	return true;
}

static void BuildStaticMeshVertexAndIndexBuffers(
	TArray<FStaticMeshBuildVertex>& OutVertices,
	TArray<TArray<uint32> >& OutPerSectionIndices,
	TArray<int32>& OutWedgeMap,
	const FRawMesh& RawMesh,
	const TMultiMap<int32,int32>& OverlappingCorners,
	float ComparisonThreshold,
	FVector BuildScale
	)
{
	TMap<int32,int32> FinalVerts;
	TArray<int32> DupVerts;
	int32 NumFaces = RawMesh.WedgeIndices.Num() / 3;

	// Process each face, build vertex buffer and per-section index buffers.
	for(int32 FaceIndex = 0; FaceIndex < NumFaces; FaceIndex++)
	{
		int32 VertexIndices[3];
		FVector CornerPositions[3];

		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			CornerPositions[CornerIndex] = GetPositionForWedge(RawMesh, FaceIndex * 3 + CornerIndex);
		}

		// Don't process degenerate triangles.
		if (PointsEqual(CornerPositions[0],CornerPositions[1], ComparisonThreshold)
			|| PointsEqual(CornerPositions[0],CornerPositions[2], ComparisonThreshold)
			|| PointsEqual(CornerPositions[1],CornerPositions[2], ComparisonThreshold))
		{
			for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
			{
				OutWedgeMap.Add(INDEX_NONE);
			}
			continue;
		}

		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			int32 WedgeIndex = FaceIndex * 3 + CornerIndex;
			FStaticMeshBuildVertex ThisVertex = BuildStaticMeshVertex(RawMesh, WedgeIndex, BuildScale);

			DupVerts.Reset();
			OverlappingCorners.MultiFind(WedgeIndex,DupVerts);
			DupVerts.Sort();

			int32 Index = INDEX_NONE;
			for (int32 k = 0; k < DupVerts.Num(); k++)
			{
				if (DupVerts[k] >= WedgeIndex)
				{
					// the verts beyond me haven't been placed yet, so these duplicates are not relevant
					break;
				}

				int32 *Location = FinalVerts.Find(DupVerts[k]);
				if (Location != NULL
					&& AreVerticesEqual(ThisVertex, OutVertices[*Location], ComparisonThreshold))
				{
					Index = *Location;
					break;
				}
			}
			if (Index == INDEX_NONE)
			{
				Index = OutVertices.Add(ThisVertex);
				FinalVerts.Add(WedgeIndex,Index);
			}
			VertexIndices[CornerIndex] = Index;
		}

		// Reject degenerate triangles.
		if (VertexIndices[0] == VertexIndices[1]
			|| VertexIndices[1] == VertexIndices[2]
			|| VertexIndices[0] == VertexIndices[2])
		{
			for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
			{
				OutWedgeMap.Add(INDEX_NONE);
			}
			continue;
		}

		// Put the indices in the material index buffer.
		int32 SectionIndex = FMath::Clamp(RawMesh.FaceMaterialIndices[FaceIndex], 0, OutPerSectionIndices.Num());
		TArray<uint32>& SectionIndices = OutPerSectionIndices[SectionIndex];
		for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
		{
			SectionIndices.Add(VertexIndices[CornerIndex]);
			OutWedgeMap.Add(VertexIndices[CornerIndex]);
		}
	}
}

void FMeshUtilities::CacheOptimizeVertexAndIndexBuffer(
	TArray<FStaticMeshBuildVertex>& Vertices,
	TArray<TArray<uint32> >& PerSectionIndices,
	TArray<int32>& WedgeMap
	)
{
	// Copy the vertices since we will be reordering them
	TArray<FStaticMeshBuildVertex> OriginalVertices = Vertices;

	// Initialize a cache that stores which indices have been assigned
	TArray<int32> IndexCache;
	IndexCache.AddUninitialized(Vertices.Num());
	FMemory::Memset(IndexCache.GetData(), INDEX_NONE, IndexCache.Num() * IndexCache.GetTypeSize());
	int32 NextAvailableIndex = 0;

	// Iterate through the section index buffers, 
	// Optimizing index order for the post transform cache (minimizes the number of vertices transformed), 
	// And vertex order for the pre transform cache (minimizes the amount of vertex data fetched by the GPU).
	for (int32 SectionIndex = 0; SectionIndex < PerSectionIndices.Num(); SectionIndex++)
	{
		TArray<uint32>& Indices = PerSectionIndices[SectionIndex];

		if (Indices.Num())
		{
			// Optimize the index buffer for the post transform cache with.
			CacheOptimizeIndexBuffer(Indices);

			// Copy the index buffer since we will be reordering it
			TArray<uint32> OriginalIndices = Indices;

			// Go through the indices and assign them new values that are coherent where possible
			for (int32 Index = 0; Index < Indices.Num(); Index++)
			{
				const int32 CachedIndex = IndexCache[OriginalIndices[Index]];

				if (CachedIndex == INDEX_NONE)
				{
					// No new index has been allocated for this existing index, assign a new one
					Indices[Index] = NextAvailableIndex;
					// Mark what this index has been assigned to
					IndexCache[OriginalIndices[Index]] = NextAvailableIndex;
					NextAvailableIndex++;
				}
				else
				{
					// Reuse an existing index assignment
					Indices[Index] = CachedIndex;
				}
				// Reorder the vertices based on the new index assignment
				Vertices[Indices[Index]] = OriginalVertices[OriginalIndices[Index]];
			}
		}
	}

	for (int32 i = 0; i < WedgeMap.Num(); i++)
	{
		int32 MappedIndex = WedgeMap[i];
		if (MappedIndex != INDEX_NONE)
		{
			WedgeMap[i] = IndexCache[MappedIndex];
		}
	}
}

static void ApplyScaling( FRawMesh& Mesh, float BuildScale )
{
	const int32 NumFaces = Mesh.WedgeIndices.Num() / 3;

	for(int32 FaceIndex = 0; FaceIndex < NumFaces; FaceIndex++)
	{
		for (int32 TriVertexIndex = 0; TriVertexIndex < 3; TriVertexIndex++)
		{
			const int32 WedgeIndex = FaceIndex * 3 + TriVertexIndex;
			int32 VertexIndex = Mesh.WedgeIndices[WedgeIndex];
			Mesh.VertexPositions[VertexIndex] *= BuildScale;
		}
	}

}

bool FMeshUtilities::BuildStaticMesh(
	FStaticMeshRenderData& OutRenderData,
	TArray<FStaticMeshSourceModel>& SourceModels,
	const TArray<UMaterialInterface*>& Materials,
	const FStaticMeshLODGroup& LODGroup
	)
{
	TIndirectArray<FRawMesh> LODMeshes;
	TIndirectArray<TMultiMap<int32,int32> > LODOverlappingCorners;
	float LODMaxDeviation[MAX_STATIC_MESH_LODS];
	FMeshBuildSettings LODBuildSettings[MAX_STATIC_MESH_LODS];

	// Gather source meshes for each LOD.
	for (int32 LODIndex = 0; LODIndex < SourceModels.Num(); ++LODIndex)
	{
		FStaticMeshSourceModel& SrcModel = SourceModels[LODIndex];
		FRawMesh& RawMesh = *new(LODMeshes) FRawMesh;
		TMultiMap<int32,int32>& OverlappingCorners = *new(LODOverlappingCorners) TMultiMap<int32,int32>;

		if (!SrcModel.RawMeshBulkData->IsEmpty())
		{
			SrcModel.RawMeshBulkData->LoadRawMesh(RawMesh);
			// Make sure the raw mesh is not irreparably malformed.
			if (!RawMesh.IsValidOrFixable())
			{
				UE_LOG(LogMeshUtilities,Error,TEXT("Raw mesh is corrupt for LOD%d."), LODIndex);
				return false;
			}
			LODBuildSettings[LODIndex] = SrcModel.BuildSettings;

			float ComparisonThreshold = GetComparisonThreshold(LODBuildSettings[LODIndex]);
			int32 NumWedges = RawMesh.WedgeIndices.Num();

			// Find overlapping corners to accelerate adjacency.
			FindOverlappingCorners(OverlappingCorners, RawMesh, ComparisonThreshold);

			// Figure out if we should recompute normals and tangents.
			bool bRecomputeNormals = SrcModel.BuildSettings.bRecomputeNormals || RawMesh.WedgeTangentZ.Num() == 0;
			bool bRecomputeTangents = SrcModel.BuildSettings.bRecomputeTangents || RawMesh.WedgeTangentX.Num() == 0 || RawMesh.WedgeTangentY.Num() == 0;

			// Dump normals and tangents if we are recomputing them.
			if (bRecomputeTangents)
			{
				RawMesh.WedgeTangentX.Empty(NumWedges);
				RawMesh.WedgeTangentX.AddZeroed(NumWedges);
				RawMesh.WedgeTangentY.Empty(NumWedges);
				RawMesh.WedgeTangentY.AddZeroed(NumWedges);
			}
			if (bRecomputeNormals)
			{
				RawMesh.WedgeTangentZ.Empty(NumWedges);
				RawMesh.WedgeTangentZ.AddZeroed(NumWedges);
			}

			// Compute any missing tangents.
			{
				// Static meshes always blend normals of overlapping corners.
				uint32 TangentOptions = ETangentOptions::BlendOverlappingNormals;
				if (SrcModel.BuildSettings.bRemoveDegenerates)
				{
					// If removing degenerate triangles, ignore them when computing tangents.
					TangentOptions |= ETangentOptions::IgnoreDegenerateTriangles;
				}
				ComputeTangents(RawMesh, OverlappingCorners, TangentOptions);
			}

			// At this point the mesh will have valid tangents.
			check(RawMesh.WedgeTangentX.Num() == NumWedges);
			check(RawMesh.WedgeTangentY.Num() == NumWedges);
			check(RawMesh.WedgeTangentZ.Num() == NumWedges);
		}
		else if (LODIndex > 0 && MeshReduction)
		{
			// If a raw mesh is not explicitly provided, use the raw mesh of the
			// next highest LOD.
			RawMesh = LODMeshes[LODIndex-1];
			OverlappingCorners = LODOverlappingCorners[LODIndex-1];
			LODBuildSettings[LODIndex] = LODBuildSettings[LODIndex-1];
		}
	}
	check(LODMeshes.Num() == SourceModels.Num());
	check(LODOverlappingCorners.Num() == SourceModels.Num());

	// Bail if there is no raw mesh data from which to build a renderable mesh.
	if (LODMeshes.Num() == 0 || LODMeshes[0].WedgeIndices.Num() == 0)
	{
		return false;
	}

	// Reduce each LOD mesh according to its reduction settings.
	OutRenderData.bReducedBySimplygon = false;
	int32 NumValidLODs = 0;
	for (int32 LODIndex = 0; LODIndex < SourceModels.Num(); ++LODIndex)
	{
		const FStaticMeshSourceModel& SrcModel = SourceModels[LODIndex];
		FMeshReductionSettings ReductionSettings = LODGroup.GetSettings(SrcModel.ReductionSettings, LODIndex);
		LODMaxDeviation[NumValidLODs] = 0.0f;
		if (LODIndex != NumValidLODs)
		{
			LODBuildSettings[NumValidLODs] = LODBuildSettings[LODIndex];
			LODOverlappingCorners[NumValidLODs] = LODOverlappingCorners[LODIndex];
		}

		if (MeshReduction && (ReductionSettings.PercentTriangles < 1.0f || ReductionSettings.MaxDeviation > 0.0f))
		{
			FRawMesh InMesh = LODMeshes[ReductionSettings.BaseLODModel];
			FRawMesh& DestMesh = LODMeshes[NumValidLODs];
			TMultiMap<int32,int32>& DestOverlappingCorners = LODOverlappingCorners[NumValidLODs];

			MeshReduction->Reduce(DestMesh, LODMaxDeviation[NumValidLODs], InMesh, ReductionSettings);
			if (DestMesh.WedgeIndices.Num() > 0 && !DestMesh.IsValid())
			{
				UE_LOG(LogMeshUtilities,Error,TEXT("Mesh reduction produced a corrupt mesh for LOD%d"),LODIndex);
				return false;
			}
			OutRenderData.bReducedBySimplygon = bUsingSimplygon;

			// Recompute adjacency information.
			DestOverlappingCorners.Reset();
			float ComparisonThreshold = GetComparisonThreshold(LODBuildSettings[NumValidLODs]);
			FindOverlappingCorners(DestOverlappingCorners, DestMesh, ComparisonThreshold);
		}

		if (LODMeshes[NumValidLODs].WedgeIndices.Num() > 0)
		{
			NumValidLODs++;
		}
	}

	if (NumValidLODs < 1)
	{
		return false;
	}

	// Generate per-LOD rendering data.
	OutRenderData.AllocateLODResources(NumValidLODs);
	for (int32 LODIndex = 0; LODIndex < NumValidLODs; ++LODIndex)
	{
		FStaticMeshLODResources& LODModel = OutRenderData.LODResources[LODIndex];
		FRawMesh& RawMesh = LODMeshes[LODIndex];
		LODModel.MaxDeviation = LODMaxDeviation[LODIndex];

		TArray<FStaticMeshBuildVertex> Vertices;
		TArray<TArray<uint32> > PerSectionIndices;

		// Find out how many sections are in the mesh.
		int32 MaxMaterialIndex = -1;
		for (int32 FaceIndex = 0; FaceIndex < RawMesh.FaceMaterialIndices.Num(); FaceIndex++)
		{
			MaxMaterialIndex = FMath::Max<int32>(RawMesh.FaceMaterialIndices[FaceIndex],MaxMaterialIndex);
		}
		MaxMaterialIndex = FMath::Min(MaxMaterialIndex, MAX_MESH_MATERIAL_INDEX);

		while (MaxMaterialIndex >= LODModel.Sections.Num())
		{
			FStaticMeshSection* Section = new(LODModel.Sections) FStaticMeshSection();
			Section->MaterialIndex = LODModel.Sections.Num() - 1;
			new(PerSectionIndices) TArray<uint32>;
		}

		// Build and cache optimize vertex and index buffers.
		{
			// TODO_STATICMESH: The wedge map is only valid for LODIndex 0 if no reduction has been performed.
			// We can compute an approximate one instead for other LODs.
			TArray<int32> TempWedgeMap;
			TArray<int32>& WedgeMap = (LODIndex == 0 && SourceModels[0].ReductionSettings.PercentTriangles >= 1.0f) ? OutRenderData.WedgeMap : TempWedgeMap;
			float ComparisonThreshold = GetComparisonThreshold(LODBuildSettings[LODIndex]);
			BuildStaticMeshVertexAndIndexBuffers(Vertices, PerSectionIndices, WedgeMap, RawMesh, LODOverlappingCorners[LODIndex], ComparisonThreshold, LODBuildSettings[LODIndex].BuildScale3D );
			check(WedgeMap.Num() == RawMesh.WedgeIndices.Num());
			CacheOptimizeVertexAndIndexBuffer(Vertices, PerSectionIndices, WedgeMap);
			check(WedgeMap.Num() == RawMesh.WedgeIndices.Num());
		}

		// Initialize the vertex buffer.
		int32 NumTexCoords = ComputeNumTexCoords(RawMesh, MAX_STATIC_TEXCOORDS);
		LODModel.VertexBuffer.SetUseFullPrecisionUVs(LODBuildSettings[LODIndex].bUseFullPrecisionUVs);	
		LODModel.VertexBuffer.Init(Vertices,NumTexCoords);
		LODModel.PositionVertexBuffer.Init(Vertices);
		LODModel.ColorVertexBuffer.Init(Vertices);

		// Concatenate the per-section index buffers.
		TArray<uint32> CombinedIndices;
		bool bNeeds32BitIndices = false;
		for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
		{
			FStaticMeshSection& Section = LODModel.Sections[SectionIndex];
			TArray<uint32> const& SectionIndices = PerSectionIndices[SectionIndex];
			Section.FirstIndex = 0;
			Section.NumTriangles = 0;
			Section.MinVertexIndex = 0;
			Section.MaxVertexIndex = 0;

			if (SectionIndices.Num())
			{
				Section.FirstIndex = CombinedIndices.Num();
				Section.NumTriangles = SectionIndices.Num() / 3;

				CombinedIndices.AddUninitialized(SectionIndices.Num());
				uint32* DestPtr = &CombinedIndices[Section.FirstIndex];
				uint32 const* SrcPtr = SectionIndices.GetTypedData();

				Section.MinVertexIndex = *SrcPtr;
				Section.MaxVertexIndex = *SrcPtr;

				for (int32 Index = 0; Index < SectionIndices.Num(); Index++)
				{
					uint32 VertIndex = *SrcPtr++;

					bNeeds32BitIndices |= (VertIndex > MAX_uint16);
					Section.MinVertexIndex = FMath::Min<uint32>(VertIndex,Section.MinVertexIndex);
					Section.MaxVertexIndex = FMath::Max<uint32>(VertIndex,Section.MaxVertexIndex);
					*DestPtr++ = VertIndex;
				}
			}
		}
		LODModel.IndexBuffer.SetIndices(CombinedIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);

		if (LODIndex == 0)
		{
			ComputeStreamingTextureFactors(
				OutRenderData.StreamingTextureFactors,
				&OutRenderData.MaxStreamingTextureFactor,
				RawMesh,
				LODBuildSettings[LODIndex].BuildScale3D
				);
		}

		// Build the depth-only index buffer.
		{
			TArray<uint32> DepthOnlyIndices;
			BuildDepthOnlyIndexBuffer(
				DepthOnlyIndices,
				Vertices,
				CombinedIndices,
				LODModel.Sections
				);
			CacheOptimizeIndexBuffer(DepthOnlyIndices);
			LODModel.DepthOnlyIndexBuffer.SetIndices(DepthOnlyIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);
		}

		// Build a list of wireframe edges in the static mesh.
		{
			TArray<FMeshEdge> Edges;
			TArray<uint32> WireframeIndices;

			FStaticMeshEdgeBuilder(CombinedIndices,Vertices,Edges).FindEdges();
			WireframeIndices.Empty(2 * Edges.Num());
			for(int32 EdgeIndex = 0;EdgeIndex < Edges.Num();EdgeIndex++)
			{
				FMeshEdge&	Edge = Edges[EdgeIndex];
				WireframeIndices.Add(Edge.Vertices[0]);
				WireframeIndices.Add(Edge.Vertices[1]);
			}
			LODModel.WireframeIndexBuffer.SetIndices(WireframeIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);
		}

		// Build the adjacency index buffer used for tessellation.
		{
			TArray<uint32> AdjacencyIndices;

			BuildStaticAdjacencyIndexBuffer(
				LODModel.PositionVertexBuffer,
				LODModel.VertexBuffer,
				CombinedIndices,
				AdjacencyIndices
				);
			LODModel.AdjacencyIndexBuffer.SetIndices(AdjacencyIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);
		}
	}

	// Copy the original material indices to fixup meshes before compacting of materials was done.
	if (NumValidLODs > 0)
	{
		OutRenderData.MaterialIndexToImportIndex = LODMeshes[0].MaterialIndexToImportIndex;
	}

	// Calculate the bounding box.
	FBox BoundingBox(0);
	FPositionVertexBuffer& BasePositionVertexBuffer = OutRenderData.LODResources[0].PositionVertexBuffer;
	for (uint32 VertexIndex = 0; VertexIndex < BasePositionVertexBuffer.GetNumVertices(); VertexIndex++)
	{
		BoundingBox += BasePositionVertexBuffer.VertexPosition(VertexIndex);
	}
	BoundingBox.GetCenterAndExtents(OutRenderData.Bounds.Origin,OutRenderData.Bounds.BoxExtent);

	// Calculate the bounding sphere, using the center of the bounding box as the origin.
	OutRenderData.Bounds.SphereRadius = 0.0f;
	for (uint32 VertexIndex = 0; VertexIndex < BasePositionVertexBuffer.GetNumVertices(); VertexIndex++)
	{
		OutRenderData.Bounds.SphereRadius = FMath::Max(
			(BasePositionVertexBuffer.VertexPosition(VertexIndex) - OutRenderData.Bounds.Origin).Size(),
			OutRenderData.Bounds.SphereRadius
			);
	}
	
	{
		FStaticMeshLODResources& LODModel = OutRenderData.LODResources[0];

		GenerateSignedDistanceFieldVolumeData(
			LODModel,
			Materials,
			OutRenderData.Bounds,
			LODBuildSettings[0].DistanceFieldResolutionScale);
	}

	return true;
}


bool FMeshUtilities::BuildSkeletalMesh( FStaticLODModel& LODModel, const FReferenceSkeleton& RefSkeleton, const TArray<FVertInfluence>& Influences, const TArray<FMeshWedge>& Wedges, const TArray<FMeshFace>& Faces, const TArray<FVector>& Points, const TArray<int32>& PointToOriginalMap, bool bKeepOverlappingVertices, bool bComputeNormals, bool bComputeTangents )
{
#if WITH_EDITORONLY_DATA
	bool bTooManyVerts = false;

	check(PointToOriginalMap.Num() == Points.Num());

	// Calculate face tangent vectors.
	TArray<FVector>	FaceTangentX;
	TArray<FVector>	FaceTangentY;
	FaceTangentX.AddUninitialized(Faces.Num());
	FaceTangentY.AddUninitialized(Faces.Num());

	if( bComputeNormals || bComputeTangents )
	{
		for(int32 FaceIndex = 0;FaceIndex < Faces.Num();FaceIndex++)
		{
			FVector	P1 = Points[Wedges[Faces[FaceIndex].iWedge[0]].iVertex],
				P2 = Points[Wedges[Faces[FaceIndex].iWedge[1]].iVertex],
				P3 = Points[Wedges[Faces[FaceIndex].iWedge[2]].iVertex];
			FVector	TriangleNormal = FPlane(P3,P2,P1);
			FMatrix	ParameterToLocal(
				FPlane(	P2.X - P1.X,	P2.Y - P1.Y,	P2.Z - P1.Z,	0	),
				FPlane(	P3.X - P1.X,	P3.Y - P1.Y,	P3.Z - P1.Z,	0	),
				FPlane(	P1.X,			P1.Y,			P1.Z,			0	),
				FPlane(	0,				0,				0,				1	)
				);

			float	U1 = Wedges[Faces[FaceIndex].iWedge[0]].UVs[0].X,
				U2 = Wedges[Faces[FaceIndex].iWedge[1]].UVs[0].X,
				U3 = Wedges[Faces[FaceIndex].iWedge[2]].UVs[0].X,
				V1 = Wedges[Faces[FaceIndex].iWedge[0]].UVs[0].Y,
				V2 = Wedges[Faces[FaceIndex].iWedge[1]].UVs[0].Y,
				V3 = Wedges[Faces[FaceIndex].iWedge[2]].UVs[0].Y;

			FMatrix	ParameterToTexture(
				FPlane(	U2 - U1,	V2 - V1,	0,	0	),
				FPlane(	U3 - U1,	V3 - V1,	0,	0	),
				FPlane(	U1,			V1,			1,	0	),
				FPlane(	0,			0,			0,	1	)
				);

			FMatrix	TextureToLocal = ParameterToTexture.InverseSlow() * ParameterToLocal;
			FVector	TangentX = TextureToLocal.TransformVector(FVector(1,0,0)).SafeNormal(),
				TangentY = TextureToLocal.TransformVector(FVector(0,1,0)).SafeNormal(),
				TangentZ;

			TangentX = TangentX - TriangleNormal * (TangentX | TriangleNormal);
			TangentY = TangentY - TriangleNormal * (TangentY | TriangleNormal);

			FaceTangentX[FaceIndex] = TangentX.SafeNormal();
			FaceTangentY[FaceIndex] = TangentY.SafeNormal();
		}
	}

	TArray<int32>	WedgeInfluenceIndices;

	// Find wedge influences.
	TMap<uint32,uint32> VertexIndexToInfluenceIndexMap;

	for(uint32 LookIdx = 0;LookIdx < (uint32)Influences.Num();LookIdx++)
	{
		// Order matters do not allow the map to overwrite an existing value.
		if( !VertexIndexToInfluenceIndexMap.Find( Influences[LookIdx].VertIndex) )
		{
			VertexIndexToInfluenceIndexMap.Add( Influences[LookIdx].VertIndex, LookIdx );
		}
	}

	for(int32 WedgeIndex = 0;WedgeIndex < Wedges.Num();WedgeIndex++)
	{
		uint32* InfluenceIndex = VertexIndexToInfluenceIndexMap.Find( Wedges[WedgeIndex].iVertex );

		check( InfluenceIndex );

		WedgeInfluenceIndices.Add( *InfluenceIndex );
	}

 	check(Wedges.Num() == WedgeInfluenceIndices.Num());

	// Calculate smooth wedge tangent vectors.

	if( IsInGameThread() )
	{
		// Only update status if in the game thread.  When importing morph targets, this function can run in another thread
		GWarn->BeginSlowTask( NSLOCTEXT("UnrealEd", "ProcessingSkeletalTriangles", "Processing Mesh Triangles"), true );
	}


	// To accelerate generation of adjacency, we'll create a table that maps each vertex index
	// to its overlapping vertices, and a table that maps a vertex to the its influenced faces
	TMultiMap<int32,int32> Vert2Duplicates;
	TMultiMap<int32,int32> Vert2Faces;
	{
		// Create a list of vertex Z/index pairs
		TArray<FSkeletalMeshVertIndexAndZ> VertIndexAndZ;
		VertIndexAndZ.Empty(Points.Num());
		for (int32 i = 0; i < Points.Num(); i++)
		{
			FSkeletalMeshVertIndexAndZ iandz;
			iandz.Index = i;
			iandz.Z = Points[i].Z;
			VertIndexAndZ.Add(iandz);
		}

		// Sorting function for vertex Z/index pairs
		struct FCompareFSkeletalMeshVertIndexAndZ
		{
			FORCEINLINE bool operator()( const FSkeletalMeshVertIndexAndZ& A, const FSkeletalMeshVertIndexAndZ& B ) const
			{
				return A.Z < B.Z;
			}
		};

		// Sort the vertices by z value
		VertIndexAndZ.Sort( FCompareFSkeletalMeshVertIndexAndZ() );

		// Search for duplicates, quickly!
		for (int32 i = 0; i < VertIndexAndZ.Num(); i++)
		{
			// only need to search forward, since we add pairs both ways
			for (int32 j = i + 1; j < VertIndexAndZ.Num(); j++)
			{
				if (FMath::Abs(VertIndexAndZ[j].Z - VertIndexAndZ[i].Z) > THRESH_POINTS_ARE_SAME )
				{
					// our list is sorted, so there can't be any more dupes
					break;
				}

				// check to see if the points are really overlapping
				if(PointsEqual(
					Points[VertIndexAndZ[i].Index],
					Points[VertIndexAndZ[j].Index] ))					
				{
					Vert2Duplicates.Add(VertIndexAndZ[i].Index,VertIndexAndZ[j].Index);
					Vert2Duplicates.Add(VertIndexAndZ[j].Index,VertIndexAndZ[i].Index);
				}
			}
		}

		// we are done with this
		VertIndexAndZ.Empty();

		// now create a map from vert indices to faces
		for(int32 FaceIndex = 0;FaceIndex < Faces.Num();FaceIndex++)
		{
			const FMeshFace&	Face = Faces[FaceIndex];
			for(int32 VertexIndex = 0;VertexIndex < 3;VertexIndex++)
			{
				Vert2Faces.AddUnique(Wedges[Face.iWedge[VertexIndex]].iVertex,FaceIndex);
			}
		}
	}

	TArray<FSkinnedMeshChunk*> Chunks;
	TArray<int32> AdjacentFaces;
	TArray<int32> DupVerts;
	TArray<int32> DupFaces;

	for(int32 FaceIndex = 0;FaceIndex < Faces.Num();FaceIndex++)
	{
		// Only update the status progress bar if we are in the gamethread and every thousand faces. 
		// Updating status is extremely slow
		if( IsInGameThread() && FaceIndex % 5000 == 0 )
		{
			// Only update status if in the game thread.  When importing morph targets, this function can run in another thread
			GWarn->StatusUpdate( FaceIndex, Faces.Num(), NSLOCTEXT("UnrealEd", "ProcessingSkeletalTriangles", "Processing Mesh Triangles") );
		}

		const FMeshFace&	Face = Faces[FaceIndex];

		FVector	VertexTangentX[3],
				VertexTangentY[3],
				VertexTangentZ[3];

		if( bComputeNormals || bComputeTangents )
		{
			for(int32 VertexIndex = 0;VertexIndex < 3;VertexIndex++)
			{
				VertexTangentX[VertexIndex] = FVector::ZeroVector;
				VertexTangentY[VertexIndex] = FVector::ZeroVector;
				VertexTangentZ[VertexIndex] = FVector::ZeroVector;
			}

			FVector	TriangleNormal = FPlane(
				Points[Wedges[Face.iWedge[2]].iVertex],
				Points[Wedges[Face.iWedge[1]].iVertex],
				Points[Wedges[Face.iWedge[0]].iVertex]
			);
			float	Determinant = FVector::Triple(FaceTangentX[FaceIndex],FaceTangentY[FaceIndex],TriangleNormal);

			// Start building a list of faces adjacent to this triangle
			AdjacentFaces.Reset();
			for(int32 VertexIndex = 0;VertexIndex < 3;VertexIndex++)
			{
				int32 vert = Wedges[Face.iWedge[VertexIndex]].iVertex;
				DupVerts.Reset();
				Vert2Duplicates.MultiFind(vert,DupVerts);
				DupVerts.Add(vert); // I am a "dupe" of myself
				for (int32 k = 0; k < DupVerts.Num(); k++)
				{
					DupFaces.Reset();
					Vert2Faces.MultiFind(DupVerts[k],DupFaces);
					for (int32 l = 0; l < DupFaces.Num(); l++)
					{
						AdjacentFaces.AddUnique(DupFaces[l]);
					}
				}
			}

			// Process adjacent faces
			for(int32 AdjacentFaceIndex = 0;AdjacentFaceIndex < AdjacentFaces.Num();AdjacentFaceIndex++)
			{
				int32 OtherFaceIndex = AdjacentFaces[AdjacentFaceIndex];
				const FMeshFace&	OtherFace = Faces[OtherFaceIndex];
				FVector		OtherTriangleNormal = FPlane(
					Points[Wedges[OtherFace.iWedge[2]].iVertex],
					Points[Wedges[OtherFace.iWedge[1]].iVertex],
					Points[Wedges[OtherFace.iWedge[0]].iVertex]
				);
				float		OtherFaceDeterminant = FVector::Triple(FaceTangentX[OtherFaceIndex],FaceTangentY[OtherFaceIndex],OtherTriangleNormal);

				for(int32 VertexIndex = 0;VertexIndex < 3;VertexIndex++)
				{
					for(int32 OtherVertexIndex = 0;OtherVertexIndex < 3;OtherVertexIndex++)
					{
						if(PointsEqual(
							Points[Wedges[OtherFace.iWedge[OtherVertexIndex]].iVertex],
							Points[Wedges[Face.iWedge[VertexIndex]].iVertex]
						))					
						{
							if(Determinant * OtherFaceDeterminant > 0.0f && SkeletalMeshTools::SkeletalMesh_UVsEqual(Wedges[OtherFace.iWedge[OtherVertexIndex]],Wedges[Face.iWedge[VertexIndex]]))
							{
								VertexTangentX[VertexIndex] += FaceTangentX[OtherFaceIndex];
								VertexTangentY[VertexIndex] += FaceTangentY[OtherFaceIndex];
							}

							// Only contribute 'normal' if the vertices are truly one and the same to obey hard "smoothing" edges baked into 
							// the mesh by vertex duplication
							if( Wedges[OtherFace.iWedge[OtherVertexIndex]].iVertex == Wedges[Face.iWedge[VertexIndex]].iVertex ) 
							{
								VertexTangentZ[VertexIndex] += OtherTriangleNormal;
							}
						}
					}
				}
			}
		}

		// Find a chunk which matches this triangle.
		FSkinnedMeshChunk* Chunk = NULL;
		for (int32 i = 0; i < Chunks.Num(); ++i)
		{
			if (Chunks[i]->MaterialIndex == Face.MeshMaterialIndex)
			{
				Chunk = Chunks[i];
				break;
			}
		}
		if (Chunk == NULL)
		{
			Chunk = new FSkinnedMeshChunk();
			Chunk->MaterialIndex = Face.MeshMaterialIndex;
			Chunk->OriginalSectionIndex = Chunks.Num();
			Chunks.Add(Chunk);
		}

		uint32 TriangleIndices[3];

		for(int32 VertexIndex = 0;VertexIndex < 3;VertexIndex++)
		{
			FSoftSkinBuildVertex	Vertex;

			Vertex.Position = Points[Wedges[Face.iWedge[VertexIndex]].iVertex];

			FVector TangentX,TangentY,TangentZ;

			if( bComputeNormals || bComputeTangents )
			{
				TangentX = VertexTangentX[VertexIndex].SafeNormal();
				TangentY = VertexTangentY[VertexIndex].SafeNormal();

				if( bComputeNormals )
				{
					TangentZ = VertexTangentZ[VertexIndex].SafeNormal();
				}
				else
				{
					TangentZ = Face.TangentZ[VertexIndex];
				}

				TangentY -= TangentX * (TangentX | TangentY);
				TangentY.Normalize();

				TangentX -= TangentZ * (TangentZ | TangentX);
				TangentY -= TangentZ * (TangentZ | TangentY);

				TangentX.Normalize();
				TangentY.Normalize();
			}
			else
			{
				TangentX = Face.TangentX[VertexIndex];
				TangentY = Face.TangentY[VertexIndex];
				TangentZ = Face.TangentZ[VertexIndex];

				// Normalize overridden tangents.  Its possible for them to import un-normalized.
				TangentX.Normalize();
				TangentY.Normalize();
				TangentZ.Normalize();
			}

			Vertex.TangentX = TangentX;
			Vertex.TangentY = TangentY;
			Vertex.TangentZ = TangentZ;

			FMemory::Memcpy( Vertex.UVs,  Wedges[Face.iWedge[VertexIndex]].UVs, sizeof(FVector2D)*MAX_TEXCOORDS);	
			Vertex.Color = Wedges[Face.iWedge[VertexIndex]].Color;

			{
				// Count the influences.

				int32 InfIdx = WedgeInfluenceIndices[Face.iWedge[VertexIndex]];
				int32 LookIdx = InfIdx;

				uint32 InfluenceCount = 0;
				while( Influences.IsValidIndex(LookIdx) && (Influences[LookIdx].VertIndex == Wedges[Face.iWedge[VertexIndex]].iVertex) )
				{			
					InfluenceCount++;
					LookIdx++;
				}
				InfluenceCount = FMath::Min<uint32>(InfluenceCount,MAX_TOTAL_INFLUENCES);

				// Setup the vertex influences.

				Vertex.InfluenceBones[0] = 0;
				Vertex.InfluenceWeights[0] = 255;
				for(uint32 i = 1;i < MAX_TOTAL_INFLUENCES;i++)
				{
					Vertex.InfluenceBones[i] = 0;
					Vertex.InfluenceWeights[i] = 0;
				}

				uint32	TotalInfluenceWeight = 0;
				for(uint32 i = 0;i < InfluenceCount;i++)
				{
					FBoneIndexType BoneIndex = (FBoneIndexType)Influences[InfIdx+i].BoneIndex;
					if( BoneIndex >= RefSkeleton.GetNum() )
						continue;

					Vertex.InfluenceBones[i] = BoneIndex;
					Vertex.InfluenceWeights[i] = (uint8)(Influences[InfIdx+i].Weight * 255.0f);
					TotalInfluenceWeight += Vertex.InfluenceWeights[i];
				}
				Vertex.InfluenceWeights[0] += 255 - TotalInfluenceWeight;
			}

			// Add the vertex as well as its original index in the points array
			Vertex.PointWedgeIdx = Wedges[Face.iWedge[VertexIndex]].iVertex;

			int32	V = SkeletalMeshTools::AddSkinVertex(Chunk->Vertices,Vertex,bKeepOverlappingVertices);


			// set the index entry for the newly added vertex
			// check(V >= 0 && V <= MAX_uint16);
#if DISALLOW_32BIT_INDICES
			if (V > MAX_uint16)
			{
				bTooManyVerts = true;
			}
			TriangleIndices[VertexIndex] = (uint16)V;
#else
			// TArray internally has int32 for capacity, so no need to test for uint32 as it's larger than int32
			TriangleIndices[VertexIndex] = (uint32)V;
#endif
		}

		if(TriangleIndices[0] != TriangleIndices[1] && TriangleIndices[0] != TriangleIndices[2] && TriangleIndices[1] != TriangleIndices[2])
		{
			for(uint32 VertexIndex = 0;VertexIndex < 3;VertexIndex++)
			{
				Chunk->Indices.Add(TriangleIndices[VertexIndex]);
			}
		}
	}

	// Chunk vertices to satisfy the requested limit.
	static const auto MaxBonesVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("Compat.MAX_GPUSKIN_BONES"));
	const int32 MaxGPUSkinBones = MaxBonesVar->GetValueOnAnyThread();
	SkeletalMeshTools::ChunkSkinnedVertices(Chunks,MaxGPUSkinBones);

	// Build the skeletal model from chunks.
	BuildSkeletalModelFromChunks(LODModel,RefSkeleton,Chunks,PointToOriginalMap);

	if( IsInGameThread() )
	{
		// Only update status if in the game thread.  When importing morph targets, this function can run in another thread
		GWarn->EndSlowTask();
	}

	// Only show these warnings if in the game thread.  When importing morph targets, this function can run in another thread and these warnings dont prevent the mesh from importing
	if( IsInGameThread() )
	{
		bool bHasBadSections = false;
		for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
		{
			FSkelMeshSection& Section = LODModel.Sections[SectionIndex];
			bHasBadSections |= (Section.NumTriangles == 0);

			// Log info about the section.
			UE_LOG(LogSkeletalMesh, Log, TEXT("Section %u: Material=%u, Chunk=%u, %u triangles"),
				SectionIndex,
				Section.MaterialIndex,
				Section.ChunkIndex,
				Section.NumTriangles
				);
		}
		if( bHasBadSections )
		{
			FMessageDialog::Open( EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "Error_SkeletalMeshHasBadSections", "Input mesh has a section with no triangles.  This mesh may not render properly.") );
		}

		if (bTooManyVerts)
		{
			UE_LOG(LogSkeletalMesh, Log, TEXT("Input mesh has too many vertices.  The generated mesh will be corrupt!"));
			FMessageDialog::Open( EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "Error_SkeletalMeshTooManyVertices", "Input mesh has too many vertices.  The generated mesh will be corrupt!  Consider adding extra materials to split up the source mesh into smaller chunks."));
		}
	}

	return true;
#else
	UE_LOG(LogSkeletalMesh, Fatal,TEXT("Cannot call FSkeletalMeshTools::CreateSkinningStreams on a console!"));
	return false;
#endif
}

void FMeshUtilities::CreateProxyMesh( 
	const TArray<AActor*>& SourceActors, 
	const struct FMeshProxySettings& InProxySettings,
	UPackage* InOuter,
	const FString& ProxyBasePackageName,
	TArray<UObject*>& OutAssetsToSync,
	FVector& OutProxyLocation)
{
	if (MeshMerging == NULL)
	{
		UE_LOG(LogMeshUtilities, Log, TEXT("No automatic mesh merging module available"));
		return;
	}

	TArray<ALandscapeProxy*>		LandscapesToMerge;
	TArray<UStaticMeshComponent*>	ComponentsToMerge;
	
	//Collect components of the corresponding actor
	for (AActor* Actor : SourceActors)
	{
		ALandscapeProxy* LandscapeActor = Cast<ALandscapeProxy>(Actor);
		if (LandscapeActor)
		{
			LandscapesToMerge.Add(LandscapeActor);
		}
		else
		{
			TArray<UStaticMeshComponent*> Components;
			Actor->GetComponents<UStaticMeshComponent>(Components);
			// TODO: support instanced static meshes
			Components.RemoveAll([](UStaticMeshComponent* Val){ return Val->IsA(UInstancedStaticMeshComponent::StaticClass()); });
			//
			ComponentsToMerge.Append(Components);
		}
	}
	
	// Convert collected static mesh components and landscapes into raw meshes and flatten materials
	TArray<FRawMesh>								RawMeshes;
	TArray<MaterialExportUtils::FFlattenMaterial>	UniqueMaterials;
	TMap<int32, TArray<int32>>						MaterialMap;
	FBox											ProxyBounds(0);
	
	RawMeshes.Empty(ComponentsToMerge.Num() + LandscapesToMerge.Num());
	UniqueMaterials.Empty(ComponentsToMerge.Num() + LandscapesToMerge.Num());
	
	// Convert static mesh components
	TArray<UMaterialInterface*> StaticMeshMaterials;
	for (UStaticMeshComponent* MeshComponent : ComponentsToMerge)
	{
		TArray<int32> RawMeshMaterialMap;
		int32 RawMeshId = RawMeshes.Add(FRawMesh());
		
		if (ConstructRawMesh(MeshComponent, RawMeshes[RawMeshId], StaticMeshMaterials, RawMeshMaterialMap))
		{
			MaterialMap.Add(RawMeshId, RawMeshMaterialMap);
			//Store the bounds for each component
			ProxyBounds+= MeshComponent->Bounds.GetBox();
		}
		else
		{
			RawMeshes.RemoveAt(RawMeshId);
		}
	}

	// Convert materials into flatten materials
	for (UMaterialInterface* Material : StaticMeshMaterials)
	{
		UniqueMaterials.Add(MaterialExportUtils::FFlattenMaterial());
		MaterialExportUtils::ExportMaterial(Material, UniqueMaterials.Last());
	}
	
	// Convert landscapes
	for (ALandscapeProxy* Landscape : LandscapesToMerge)
	{
		TArray<int32> RawMeshMaterialMap;
		int32 RawMeshId = RawMeshes.Add(FRawMesh());

		if (Landscape->ExportToRawMesh(INDEX_NONE, RawMeshes[RawMeshId]))
		{
			// Landscape has one unique material
			int32 MatIdx = UniqueMaterials.Add(MaterialExportUtils::FFlattenMaterial());
			RawMeshMaterialMap.Add(MatIdx);
			MaterialMap.Add(RawMeshId, RawMeshMaterialMap);
			// This is texture resolution for a landscape, probably need to be calculated using landscape size
			UniqueMaterials.Last().DiffuseSize = FIntPoint(1024, 1024);
			// FIXME: Landscape material exporter currently renders world space normal map, so it can't be merged with other meshes normal maps
			UniqueMaterials.Last().NormalSize = FIntPoint::ZeroValue;
			MaterialExportUtils::ExportMaterial(Landscape, UniqueMaterials.Last());
			
			//Store the bounds for each component
			ProxyBounds+= Landscape->GetComponentsBoundingBox(true);
		}
		else
		{
			RawMeshes.RemoveAt(RawMeshId);
		}
	}

	if (RawMeshes.Num() == 0)
	{
		return;
	}
	
	//For each raw mesh, re-map the material indices according to the MaterialMap
	for (int32 RawMeshIndex = 0; RawMeshIndex < RawMeshes.Num(); ++RawMeshIndex)
	{
		FRawMesh& RawMesh = RawMeshes[RawMeshIndex];
		const TArray<int32>& Map = *MaterialMap.Find(RawMeshIndex);
		int32 NumFaceMaterials = RawMesh.FaceMaterialIndices.Num();

		for (int32 FaceMaterialIndex = 0; FaceMaterialIndex < NumFaceMaterials; ++FaceMaterialIndex)
		{
			int32 LocalMaterialIndex = RawMesh.FaceMaterialIndices[FaceMaterialIndex];
			int32 GlobalIndex = Map[LocalMaterialIndex];

			//Assign the new material index to the raw mesh
			RawMesh.FaceMaterialIndices[FaceMaterialIndex] = GlobalIndex;
		}
	}

	//
	// Build proxy mesh
	//
	FRawMesh								ProxyRawMesh;
	MaterialExportUtils::FFlattenMaterial	ProxyFlattenMaterial;
	
	MeshMerging->BuildProxy(RawMeshes, UniqueMaterials, InProxySettings, ProxyRawMesh, ProxyFlattenMaterial);

	//Transform the proxy mesh
	OutProxyLocation = ProxyBounds.GetCenter();
	for(FVector& Vertex : ProxyRawMesh.VertexPositions)
	{
		Vertex-= OutProxyLocation;
	}
	
	//
	// Base asset name for a new assets
	//
	const FString AssetBaseName = FPackageName::GetShortName(ProxyBasePackageName);
	const FString AssetBasePath = FPackageName::IsShortPackageName(ProxyBasePackageName) ? 
		FPackageName::FilenameToLongPackageName(FPaths::GameContentDir()) : (FPackageName::GetLongPackagePath(ProxyBasePackageName) + TEXT("/"));

	// Construct proxy material
	UMaterial* ProxyMaterial = MaterialExportUtils::CreateMaterial(ProxyFlattenMaterial, InOuter, ProxyBasePackageName, RF_Public|RF_Standalone);
	
	// Construct proxy static mesh
	UPackage* MeshPackage = InOuter;
	if (MeshPackage == nullptr)
	{
		MeshPackage = CreatePackage(NULL, *(AssetBasePath + TEXT("SM_") + AssetBaseName));
		MeshPackage->FullyLoad();
		MeshPackage->Modify();
	}

	UStaticMesh* StaticMesh = new(MeshPackage, FName(*(TEXT("SM_") + AssetBaseName)), RF_Public|RF_Standalone) UStaticMesh(FPostConstructInitializeProperties());
	StaticMesh->InitResources();
	{
		FString OutputPath = StaticMesh->GetPathName();

		// make sure it has a new lighting guid
		StaticMesh->LightingGuid = FGuid::NewGuid();

		// Set it to use textured lightmaps. Note that Build Lighting will do the error-checking (texcoordindex exists for all LODs, etc).
		StaticMesh->LightMapResolution = 32;
		StaticMesh->LightMapCoordinateIndex = 1;

		FStaticMeshSourceModel* SrcModel = new (StaticMesh->SourceModels) FStaticMeshSourceModel();
		/*Don't allow the engine to recalculate normals*/
		SrcModel->BuildSettings.bRecomputeNormals = false;
		SrcModel->BuildSettings.bRecomputeTangents = false;
		SrcModel->BuildSettings.bRemoveDegenerates = false;
		SrcModel->BuildSettings.bUseFullPrecisionUVs = false;
		SrcModel->RawMeshBulkData->SaveRawMesh(ProxyRawMesh);

		//Assign the proxy material to the static mesh
		StaticMesh->Materials.Add(ProxyMaterial);

		StaticMesh->Build();
		StaticMesh->PostEditChange();
	}

	OutAssetsToSync.Add(ProxyMaterial);
	OutAssetsToSync.Add(StaticMesh);

#if 0 // dump flattened materials as texture assets
	for (const auto& FlatMat : UniqueMaterials)
	{
		if (FlatMat.DiffuseSamples.Num() > 1)
		{
			FString DiffuseTextureName = MakeUniqueObjectName(Package, UTexture2D::StaticClass(), *(TEXT("T_FLATTEN_") + AssetBaseName + TEXT("_D"))).ToString();
			
			UPackage* TexPackage = CreatePackage(NULL, *(AssetBasePath + DiffuseTextureName));
			TexPackage->FullyLoad();
			TexPackage->Modify();
					
			FCreateTexture2DParameters TexParams;
			TexParams.bUseAlpha = false;
			TexParams.CompressionSettings = TC_Default;
			TexParams.bDeferCompression = false;
			TexParams.bSRGB = false;

			UTexture2D* DiffuseTexture = FImageUtils::CreateTexture2D(
				FlatMat.DiffuseSize.X, 
				FlatMat.DiffuseSize.Y,
				FlatMat.DiffuseSamples,
				TexPackage,
				DiffuseTextureName,
				RF_Public|RF_Standalone, 
				TexParams);

			OutAssetsToSync.Add(DiffuseTexture);
		}
	}
#endif
}

bool FMeshUtilities::ConstructRawMesh(
	UStaticMeshComponent* InMeshComponent, 
	FRawMesh& OutRawMesh, 
	TArray<UMaterialInterface*>& OutUniqueMaterials,
	TArray<int32>& OutGlobalMaterialIndices) const
{
	UStaticMesh* SrcMesh = InMeshComponent->StaticMesh;
	if (SrcMesh == NULL)
	{
		UE_LOG(LogMeshUtilities, Warning, TEXT("No static mesh actor found in component %s."), *InMeshComponent->GetName());
		return false;
	}
	
	if (SrcMesh->SourceModels.Num() < 1)
	{
		UE_LOG(LogMeshUtilities, Warning, TEXT("No base render mesh found for %s."), *SrcMesh->GetName());
		return false;
	}

	//Always access the base mesh
	FStaticMeshSourceModel& SrcModel = SrcMesh->SourceModels[0];
	if (SrcModel.RawMeshBulkData->IsEmpty())
	{
		UE_LOG(LogMeshUtilities, Error, TEXT("Base render mesh has no imported raw mesh data %s."), *SrcMesh->GetName());
		return false;
	}

	SrcModel.RawMeshBulkData->LoadRawMesh(OutRawMesh);

	// Make sure the raw mesh is not irreparably malformed.
	if (!OutRawMesh.IsValidOrFixable())
	{
		UE_LOG(LogMeshUtilities, Error, TEXT("Raw mesh (%s) is corrupt for LOD%d."), *SrcMesh->GetName(), 1);
		return false;
	}

	//Transform the raw mesh to world space
	FTransform CtoM = InMeshComponent->ComponentToWorld;
	FMatrix InvTransCToM = CtoM.ToMatrixWithScale().Inverse().GetTransposed();

	for (FVector& Vertex : OutRawMesh.VertexPositions)
	{
		Vertex = CtoM.TransformFVector4(Vertex);
	}

	int32 NumWedges = OutRawMesh.WedgeIndices.Num();
	/* Always Recalculate normals, tangents and bitangents */
	OutRawMesh.WedgeTangentZ.Empty(NumWedges);
	OutRawMesh.WedgeTangentZ.AddZeroed(NumWedges);
	OutRawMesh.WedgeTangentX.Empty(NumWedges);
	OutRawMesh.WedgeTangentX.AddZeroed(NumWedges);
	OutRawMesh.WedgeTangentY.Empty(NumWedges);
	OutRawMesh.WedgeTangentY.AddZeroed(NumWedges);

	TMultiMap<int32,int32> OverlappingCorners;
	FindOverlappingCorners(OverlappingCorners, OutRawMesh, 0.1f);
	ComputeTangents(OutRawMesh, OverlappingCorners, ETangentOptions::BlendOverlappingNormals);

	for (int32 WedgeIndex = 0; WedgeIndex < NumWedges; ++WedgeIndex)
	{
		OutRawMesh.WedgeTangentX[WedgeIndex] = InvTransCToM.TransformVector(OutRawMesh.WedgeTangentX[WedgeIndex]).SafeNormal();
		OutRawMesh.WedgeTangentY[WedgeIndex] = InvTransCToM.TransformVector(OutRawMesh.WedgeTangentY[WedgeIndex]).SafeNormal();
		OutRawMesh.WedgeTangentZ[WedgeIndex] = InvTransCToM.TransformVector(OutRawMesh.WedgeTangentZ[WedgeIndex]).SafeNormal();
	}

	//Need to store the unique material indices in order to re-map the material indices in each rawmesh
	//Only using the base mesh
	for (const FStaticMeshSection& Section : SrcMesh->RenderData->LODResources[0].Sections) 
	{
		// Add material and store the material ID
		UMaterialInterface* MaterialToAdd = InMeshComponent->GetMaterial(Section.MaterialIndex);
		if (MaterialToAdd != NULL)
		{
			OutGlobalMaterialIndices.Add(OutUniqueMaterials.AddUnique(MaterialToAdd));
		}
		else
		{
			OutGlobalMaterialIndices.Add(INDEX_NONE);
		}
	}
			
	return true;
}



/*------------------------------------------------------------------------------
	Mesh merging 
------------------------------------------------------------------------------*/

//
// Helper class for generating square atlas for square lightmaps
//
class FLightmapPacker
{
public:
	/**
	 * @return lightmap rect in a generated atlas, invalid Rect otherwise
	 */
	FIntRect GetPackedLightmapRect(int32 Idx) const
	{
		if (PackedLigthmapSlots.IsValidIndex(Idx))
		{
			uint32 X0 = PackedLigthmapSlots[Idx]->X;
			uint32 Y0 = PackedLigthmapSlots[Idx]->Y;
			uint32 X1 = X0 + PackedLigthmapSlots[Idx]->Width;
			uint32 Y1 = Y0 + PackedLigthmapSlots[Idx]->Height;
			return FIntRect(X0, Y0, X1, Y1);
		}
		return FIntRect();
	}

	/**
	 * @return Atlas resolution, 0 - in case atlas was not created
	 */
	uint32 GetAtlasResolution() const
	{
		return PackedLightmapAtlas ? PackedLightmapAtlas->GetWidth() : 0;
	}

	/**
	 *  Attempts to pack provided square lightmaps into single atlas                                                                   
	 */ 
	bool Pack(const TArray<uint32>& LigthmapsList)
	{
		// Calculate total ligtmaps area and sort lightmaps list by resolution
		TArray<TPair<int32, uint32>> SortedLightmaps;
		float TotalArea = 0;

		for (int32 i = 0; i < LigthmapsList.Num(); ++i)
		{
			uint32 LightmapRes = LigthmapsList[i];
			TotalArea+= FMath::Square(LightmapRes);
			SortedLightmaps.Add(TPairInitializer<int32, uint32>(i, LightmapRes));
		}
		//
		SortedLightmaps.Sort([](TPair<int32, uint32> L, TPair<int32, uint32> R) { return R.Value < L.Value; });
		
		// Try to pack, increasing atlas resolution with each step
		uint32 PackedSize = FMath::RoundUpToPowerOfTwo(FMath::RoundToInt(FMath::Sqrt(TotalArea)));
		for (int32 i = 0; i < 10; ++i) // 2 iterations should be enough >.<
		{
			PackedLightmapAtlas = new FLightmapAtlas(PackedSize);
			PackedLigthmapSlots.SetNum(LigthmapsList.Num());

			for (TPair<int32, uint32> SortedLightmap : SortedLightmaps)
			{
				const FAtlasedTextureSlot* Slot = PackedLightmapAtlas->AddLightmap(SortedLightmap.Value);
				if (Slot == nullptr)
				{
					PackedLigthmapSlots.Empty();
					PackedLightmapAtlas.Reset();
					break;
				}
			
				PackedLigthmapSlots[SortedLightmap.Key] = Slot;
			}

			if (PackedLigthmapSlots.Num() == LigthmapsList.Num())
			{
				return true;
			}

			PackedSize = FMath::RoundUpToPowerOfTwo(PackedSize + 1);
		}
		
		return false;
	}

private:
	struct FLightmapAtlas : public FSlateTextureAtlas
	{
		FLightmapAtlas(uint32 InWidth)
			: FSlateTextureAtlas(InWidth, InWidth, 0, 0)
		{}

		const FAtlasedTextureSlot* AddLightmap(uint32 InWidth)
		{
			return FindSlotForTexture(InWidth, InWidth);
		}

		virtual void ConditionalUpdateTexture() override {};
	};

private:
	TScopedPointer<FLightmapAtlas>			PackedLightmapAtlas;
	TArray<const FAtlasedTextureSlot*>		PackedLigthmapSlots;
};

void FMeshUtilities::MergeActors(
	const TArray<AActor*>& SourceActors, 
	const FMeshMergingSettings& InSettings, 
	const FString& InPackageName, 
	TArray<UObject*>& OutAssetsToSync, 
	FVector& OutMergedActorLocation) const
{
	TArray<UStaticMeshComponent*> ComponentsToMerge;
	
	// Collect static mesh components
	for (AActor* Actor : SourceActors)
	{
		TArray<UStaticMeshComponent*> Components;
		Actor->GetComponents<UStaticMeshComponent>(Components);
		ComponentsToMerge.Append(Components);
	}
	
	struct FRawMeshExt
	{
		FRawMeshExt() 
			: LightMapCoordinateIndex(1)
			, LightMapRes(32)
		{}
		
		FRawMesh	Mesh;
		int32		LightMapCoordinateIndex;
		int32		LightMapRes;
		FString		AssetPackageName;
		FVector		Pivot;	
	};
	
	TArray<UMaterialInterface*>						UniqueMaterials;
	TMap<int32, TArray<int32>>						MaterialMap;
	TArray<FRawMeshExt>								SourceMeshes;
	bool											bWithVertexColors = false;
	
	// Convert collected static mesh components into raw meshes
	SourceMeshes.Empty(ComponentsToMerge.Num());

	for (UStaticMeshComponent* MeshComponent : ComponentsToMerge)
	{
		TArray<int32> MeshMaterialMap;
		int32 MeshId = SourceMeshes.Add(FRawMeshExt());

		if (ConstructRawMesh(MeshComponent, SourceMeshes[MeshId].Mesh, UniqueMaterials, MeshMaterialMap))
		{
			MaterialMap.Add(MeshId, MeshMaterialMap);

			// Store mesh lightmap info
			FIntPoint ActorLightMapRes; 
			MeshComponent->GetLightMapResolution(ActorLightMapRes.X, ActorLightMapRes.Y);
			SourceMeshes[MeshId].LightMapRes = ActorLightMapRes.X;
			SourceMeshes[MeshId].LightMapCoordinateIndex = MeshComponent->StaticMesh->LightMapCoordinateIndex;
			
			// Store component location
			SourceMeshes[MeshId].Pivot = MeshComponent->ComponentToWorld.GetLocation();
			
			// Source mesh asset package name
			SourceMeshes[MeshId].AssetPackageName = MeshComponent->StaticMesh->GetOutermost()->GetName();

			bWithVertexColors|= (SourceMeshes[MeshId].Mesh.WedgeColors.Num() != 0);
		}
		else
		{
			SourceMeshes.RemoveAt(MeshId);
		}
	}

	if (SourceMeshes.Num() == 0)
	{
		return;	
	}

	// Should we use vertex colors?
	if (!InSettings.bImportVertexColors)
	{
		bWithVertexColors = false;
	}
	
	//For each raw mesh, re-map the material indices according to the MaterialMap
	for (int32 MeshIndex = 0; MeshIndex < SourceMeshes.Num(); ++MeshIndex)
	{
		FRawMesh& RawMesh = SourceMeshes[MeshIndex].Mesh;
		const TArray<int32>& Map = *MaterialMap.Find(MeshIndex);
		for (int32& FaceMaterialIndex : RawMesh.FaceMaterialIndices)
		{
			//Assign the new material index to the raw mesh
			FaceMaterialIndex = Map[FaceMaterialIndex];
		}
	}

	FRawMeshExt MergedMesh;

	// Set target channel for lightmap UV
	MergedMesh.LightMapCoordinateIndex = InSettings.TargetLightmapUVChannel;

	// Pack lightmaps
	static const uint32 MaxLightmapRes = 2048;
	float MergedLightmapScale = 1.f;
	TArray<uint32> LightmapResList;
	for (const FRawMeshExt& SourceMesh : SourceMeshes)
	{
		LightmapResList.Add(SourceMesh.LightMapRes);
	}
							
	FLightmapPacker LightmapPacker;	
	LightmapPacker.Pack(LightmapResList);
	MergedMesh.LightMapRes = LightmapPacker.GetAtlasResolution();
	if (MergedMesh.LightMapRes > MaxLightmapRes)
	{
		MergedLightmapScale = MaxLightmapRes/(float)MergedMesh.LightMapRes;
		MergedMesh.LightMapRes = MaxLightmapRes;
	}

	// Use first mesh for naming and pivot
	MergedMesh.AssetPackageName = SourceMeshes[0].AssetPackageName;
	MergedMesh.Pivot = InSettings.bPivotPointAtZero ? FVector::ZeroVector : SourceMeshes[0].Pivot;
	
	// Merge meshes into single mesh
	for (int32 SourceMeshIdx = 0; SourceMeshIdx < SourceMeshes.Num(); ++SourceMeshIdx)
	{
		// Merge vertex data from source mesh list into single mesh
		FRawMesh& TargetRawMesh = MergedMesh.Mesh;
		const FRawMesh& SourceRawMesh = SourceMeshes[SourceMeshIdx].Mesh;
						
		TargetRawMesh.FaceSmoothingMasks.Append(SourceRawMesh.FaceSmoothingMasks);
		TargetRawMesh.FaceMaterialIndices.Append(SourceRawMesh.FaceMaterialIndices);

		int32 IndicesOffset = TargetRawMesh.VertexPositions.Num();

		for (int32 Index : SourceRawMesh.WedgeIndices)
		{
			TargetRawMesh.WedgeIndices.Add(Index + IndicesOffset);
		}

		for (FVector VertexPos : SourceRawMesh.VertexPositions)
		{
			TargetRawMesh.VertexPositions.Add(VertexPos - MergedMesh.Pivot);
		}
						
		TargetRawMesh.WedgeTangentX.Append(SourceRawMesh.WedgeTangentX);
		TargetRawMesh.WedgeTangentY.Append(SourceRawMesh.WedgeTangentY);
		TargetRawMesh.WedgeTangentZ.Append(SourceRawMesh.WedgeTangentZ);
		
		// Deal with vertex colors
		// Some meshes may have it, in this case merged mesh will be forced to have vertex colors as well
		if (bWithVertexColors)
		{
			if (SourceRawMesh.WedgeColors.Num())
			{
				TargetRawMesh.WedgeColors.Append(SourceRawMesh.WedgeColors);
			}
			else
			{
				// In case this source mesh does not have vertex colors, fill target with 0xFF
				int32 ColorsOffset = TargetRawMesh.WedgeColors.Num();
				int32 ColorsNum = SourceRawMesh.WedgeIndices.Num();
				TargetRawMesh.WedgeColors.AddUninitialized(ColorsNum);
				FMemory::Memset(&TargetRawMesh.WedgeColors[ColorsOffset], 0xFF, ColorsNum*TargetRawMesh.WedgeColors.GetTypeSize());
			}
		}

		if (InSettings.bImportAllUVChannels)
		{
	/*		const int32 NumChannels = ARRAY_COUNT(TargetRawMesh.WedgeTexCoords);
			for (int32 ChannelIdx = 0; ChannelIdx < NumChannels; ++ChannelIdx)
			{
				int32 TargetChannelIdx+= (ChannelIdx >= MergedMesh.LightMapCoordinateIndex ?)
			}*/
			TargetRawMesh.WedgeTexCoords[0].Append(SourceRawMesh.WedgeTexCoords[0]);
		}
		else // Only first UV channel will be used 
		{
			TargetRawMesh.WedgeTexCoords[0].Append(SourceRawMesh.WedgeTexCoords[0]);
		}
				
		// Transform lightmap UVs
		if (MergedMesh.LightMapRes)
		{
			FIntRect	PackedLightmapRect = LightmapPacker.GetPackedLightmapRect(SourceMeshIdx);
			FVector2D	UVOffset = FVector2D(PackedLightmapRect.Min) * MergedLightmapScale / MergedMesh.LightMapRes;

			for (FVector2D LightMapUV : SourceRawMesh.WedgeTexCoords[SourceMeshes[SourceMeshIdx].LightMapCoordinateIndex])
			{
				float UVScale = SourceMeshes[SourceMeshIdx].LightMapRes*MergedLightmapScale/MergedMesh.LightMapRes;
				TargetRawMesh.WedgeTexCoords[MergedMesh.LightMapCoordinateIndex].Add(LightMapUV * UVScale + UVOffset);
			}
		}
	}
	
	//
	//Create merged mesh asset
	//
	{
		FString AssetName;
		FString PackageName;
		if (InPackageName.IsEmpty())
		{
			AssetName = TEXT("SM_MERGED_") + FPackageName::GetShortName(MergedMesh.AssetPackageName);
			PackageName = FPackageName::GetLongPackagePath(MergedMesh.AssetPackageName) + TEXT("/") + AssetName;
		}
		else
		{
			AssetName = FPackageName::GetShortName(InPackageName);
			PackageName = InPackageName;
		}

		UPackage* Package = CreatePackage(NULL, *PackageName);
		check(Package);
		Package->FullyLoad();
		Package->Modify();

		UStaticMesh* StaticMesh = new(Package, *AssetName, RF_Public|RF_Standalone) UStaticMesh(FPostConstructInitializeProperties());
		StaticMesh->InitResources();
		
		FString OutputPath = StaticMesh->GetPathName();

		// make sure it has a new lighting guid
		StaticMesh->LightingGuid = FGuid::NewGuid();

		// Set it to use textured lightmaps. Note that Build Lighting will do the error-checking (texcoordindex exists for all LODs, etc).
		StaticMesh->LightMapResolution = MergedMesh.LightMapRes;
		StaticMesh->LightMapCoordinateIndex = MergedMesh.LightMapCoordinateIndex;

		FStaticMeshSourceModel* SrcModel = new (StaticMesh->SourceModels) FStaticMeshSourceModel();
		/*Don't allow the engine to recalculate normals*/
		SrcModel->BuildSettings.bRecomputeNormals = false;
		SrcModel->BuildSettings.bRecomputeTangents = false;
		SrcModel->BuildSettings.bRemoveDegenerates = false;
		SrcModel->BuildSettings.bUseFullPrecisionUVs = false;
		SrcModel->RawMeshBulkData->SaveRawMesh(MergedMesh.Mesh);

		// Assign materials
		for (UMaterialInterface* Material : UniqueMaterials)
		{
			StaticMesh->Materials.Add(Material);
		}
		
		StaticMesh->Build();
		StaticMesh->PostEditChange();

		OutAssetsToSync.Add(StaticMesh);
		
		//
		OutMergedActorLocation = MergedMesh.Pivot;
	}
}
	

/*------------------------------------------------------------------------------
	UV Generation
------------------------------------------------------------------------------*/

#if PLATFORM_WINDOWS
#include "Windows/D3D9MeshUtils.h"
#endif // #if PLATFORM_WINDOWS

bool FMeshUtilities::GenerateUVs(
	FRawMesh& RawMesh,
	uint32 TexCoordIndex,
	float MinChartSpacingPercent,
	float BorderSpacingPercent,
	bool bUseMaxStretch,
	const TArray< int32 >* InFalseEdgeIndices,
	uint32& MaxCharts,
	float& MaxDesiredStretch,
	FText& OutError
	)
{
#if PLATFORM_WINDOWS
	FD3D9MeshUtilities D3DMeshUtils;
	return D3DMeshUtils.GenerateUVs(RawMesh, TexCoordIndex, MinChartSpacingPercent, BorderSpacingPercent, bUseMaxStretch, InFalseEdgeIndices, MaxCharts, MaxDesiredStretch, OutError);
#else
	return false;
#endif // #if PLATFORM_WINDOWS

}

bool FMeshUtilities::LayoutUVs(FRawMesh& RawMesh, uint32 TextureResolution, uint32 TexCoordIndex, FText& OutError)
{
#if PLATFORM_WINDOWS
	FD3D9MeshUtilities D3DMeshUtils;
	return D3DMeshUtils.LayoutUVs(RawMesh, TextureResolution, TexCoordIndex, OutError);
#else
	return false;
#endif // #if PLATFORM_WINDOWS
}

/*------------------------------------------------------------------------------
	Mesh reduction.
------------------------------------------------------------------------------*/

IMeshReduction* FMeshUtilities::GetMeshReductionInterface()
{
	return MeshReduction;
}

/*------------------------------------------------------------------------------
	Mesh merging.
------------------------------------------------------------------------------*/
IMeshMerging* FMeshUtilities::GetMeshMergingInterface()
{
	return MeshMerging;
}

/*------------------------------------------------------------------------------
	Module initialization / teardown.
------------------------------------------------------------------------------*/

void FMeshUtilities::StartupModule()
{
	check(MeshReduction == NULL);
	check(MeshMerging == NULL);

	// Look for a mesh reduction module.
	{
		TArray<FName> ModuleNames;
		FModuleManager::Get().FindModules(TEXT("*MeshReduction"), ModuleNames);

		if (ModuleNames.Num())
		{
			for (int32 Index = 0; Index < ModuleNames.Num(); Index++)
			{
				IMeshReductionModule& MeshReductionModule = FModuleManager::LoadModuleChecked<IMeshReductionModule>(ModuleNames[Index]);
								
				// Look for MeshReduction interface
				if (MeshReduction == NULL)
				{
					MeshReduction = MeshReductionModule.GetMeshReductionInterface();
					if (MeshReduction)
					{
						UE_LOG(LogMeshUtilities,Log,TEXT("Using %s for automatic mesh reduction"),*ModuleNames[Index].ToString());
					}
				}

				// Look for MeshMerging interface
				if (MeshMerging == NULL)
				{
					MeshMerging = MeshReductionModule.GetMeshMergingInterface();
					if (MeshMerging)
					{
						UE_LOG(LogMeshUtilities,Log,TEXT("Using %s for automatic mesh merging"),*ModuleNames[Index].ToString());
					}
				}

				// Break early if both interfaces were found
				if (MeshReduction && MeshMerging)
				{
					break;
				}
			}
		}

		if (!MeshReduction)
		{
			UE_LOG(LogMeshUtilities,Log,TEXT("No automatic mesh reduction module available"));
		}

		if (!MeshMerging)
		{
			UE_LOG(LogMeshUtilities,Log,TEXT("No automatic mesh merging module available"));
		}
	}

	TConsoleVariableData<int32>* CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.TriangleOrderOptimization"));
	bUsingNvTriStrip = (CVar->GetValueOnGameThread() == 0);

	// Construct and cache the version string for the mesh utilities module.
	VersionString = FString::Printf(
		TEXT("%s%s%s"),
		MESH_UTILITIES_VER,
		MeshReduction ? *MeshReduction->GetVersionString() : TEXT(""),
		bUsingNvTriStrip ? TEXT("_NvTriStrip") : TEXT("")
		);
	bUsingSimplygon = VersionString.Contains(TEXT("Simplygon"));
}

void FMeshUtilities::ShutdownModule()
{
	MeshReduction = NULL;
	MeshMerging = NULL;
	VersionString.Empty();
}