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

#include "CoreMinimal.h"
#include "EngineDefines.h"
#include "Misc/MessageDialog.h"
#include "Misc/ScopedSlowTask.h"
#include "GameFramework/Actor.h"
#include "Materials/Material.h"
#include "Engine/Brush.h"
#include "Editor/EditorEngine.h"
#include "Engine/Polys.h"
#include "Engine/Selection.h"
#include "EdMode.h"
#include "EditorModeManager.h"
#include "SurfaceIterators.h"
#include "BSPOps.h"
#include "ActorEditorUtils.h"
#include "Misc/FeedbackContext.h"
#include "EngineUtils.h"

// Globals:
static TArray<uint8*> GFlags1;
static TArray<uint8*> GFlags2;

/*-----------------------------------------------------------------------------
        Helper classes.
-----------------------------------------------------------------------------*/

/**
 * Iterator used to iterate over all static brush actors in the current level.
 */
class FStaticBrushIterator
{
public:
    /**
     * Default constructor, initializing all member variables and iterating to first.
     */
    FStaticBrushIterator(UWorld* InWorld)
        : ActorIndex(-1),
          ReachedEnd(false),
          World(InWorld)
    {
        // Iterate to first.
        ++(*this);
    }

    /**
     * Iterates to next suitable actor.
     */
    void operator++()
    {
        bool FoundSuitableActor = false;
        while (!ReachedEnd && !FoundSuitableActor)
        {
            if (++ActorIndex >= World->GetCurrentLevel()->Actors.Num())
            {
                ReachedEnd = true;
            }
            else
            {
                //@todo locked levels - should we skip brushes contained by locked levels?
                ABrush* Brush      = Cast<ABrush>(World->GetCurrentLevel()->Actors[ActorIndex]);
                FoundSuitableActor = Brush && Brush->IsStaticBrush();
            }
        }
    }

    /**
     * Returns the current suitable actor pointed at by the Iterator
     *
     * @return	Current suitable actor
     */
    AActor* operator*()
    {
        check(ActorIndex <= World->GetCurrentLevel()->Actors.Num());
        check(!ReachedEnd);
        AActor* Actor = World->GetCurrentLevel()->Actors[ActorIndex];
        return Actor;
    }

    /**
     * Returns the current suitable actor pointed at by the Iterator
     *
     * @return	Current suitable actor
     */
    AActor* operator->()
    {
        check(ActorIndex <= World->GetCurrentLevel()->Actors.Num());
        check(!ReachedEnd);
        AActor* Actor = World->GetCurrentLevel()->Actors[ActorIndex];
        return Actor;
    }

    /**
     * Returns whether the iterator has reached the end and no longer points
     * to a suitable actor.
     *
     * @return true if iterator points to a suitable actor, false if it has reached the end
     */
    explicit operator bool() const
    {
        return !ReachedEnd;
    }

protected:
    /** Current index into actors array		*/
    int32 ActorIndex;
    /** Whether we already reached the end	*/
    bool ReachedEnd;
    /** Relevant world context				*/
    UWorld* World;
};

void UEditorEngine::bspRepartition(UWorld* InWorld, int32 iNode)
{
    bspBuildFPolys(InWorld->GetModel(), 1, iNode);
    bspMergeCoplanars(InWorld->GetModel(), 0, 0);
    FBSPOps::bspBuild(InWorld->GetModel(), FBSPOps::BSP_Good, 12, 70, 2, iNode);
    FBSPOps::bspRefresh(InWorld->GetModel(), 1);
}

//
// Build list of leaves.
//
static void EnlistLeaves(UModel* Model, TArray<int32>& iFronts, TArray<int32>& iBacks, int32 iNode)
{
    FBspNode& Node = Model->Nodes[iNode];

    if (Node.iFront == INDEX_NONE)
        iFronts.Add(iNode);
    else
        EnlistLeaves(Model, iFronts, iBacks, Node.iFront);

    if (Node.iBack == INDEX_NONE)
        iBacks.Add(iNode);
    else
        EnlistLeaves(Model, iFronts, iBacks, Node.iBack);
}

void UEditorEngine::csgRebuild(UWorld* InWorld)
{
    GWarn->BeginSlowTask(NSLOCTEXT("UnrealEd", "RebuildingGeometry", "Rebuilding geometry"), false);
    FBSPOps::GFastRebuild         = 1;
    ABrush::GGeometryRebuildCause = TEXT("csgRebuild");
    FinishAllSnaps();

    // Empty the model out.
    InWorld->GetModel()->Modify();
    InWorld->GetModel()->EmptyModel(1, 1);

    // Count brushes.
    int32 BrushTotal = 0, BrushCount = 0;
    for (FStaticBrushIterator It(InWorld); It; ++It)
    {
        ABrush* Brush = CastChecked<ABrush>(*It);
        if (!FActorEditorUtils::IsABuilderBrush(Brush))
        {
            BrushTotal++;
        }
    }

    // Check for the giant cube brush that is created for subtractive levels.
    // If it's found, apply the RemoveSurfaceMaterial to its polygons so they aren't lit or drawn.
    for (FStaticBrushIterator GiantCubeBrushIt(InWorld); GiantCubeBrushIt; ++GiantCubeBrushIt)
    {
        ABrush* GiantCubeBrush = CastChecked<ABrush>(*GiantCubeBrushIt);
        if (GiantCubeBrush->Brush && GiantCubeBrush->Brush->Bounds.SphereRadius > HALF_WORLD_MAX)
        {
            check(GiantCubeBrush->Brush->Polys);
            for (int32 PolyIndex = 0; PolyIndex < GiantCubeBrush->Brush->Polys->Element.Num(); PolyIndex++)
            {
                FPoly& Polygon          = GiantCubeBrush->Brush->Polys->Element[PolyIndex];
                const float PolygonArea = Polygon.Area();
                if (PolygonArea > WORLD_MAX * WORLD_MAX * 0.99f && PolygonArea < WORLD_MAX * WORLD_MAX * 1.01f)
                {
                    Polygon.Material = GEngine->RemoveSurfaceMaterial;
                }
            }
        }
    }

    // Compose all structural brushes and portals.
    for (FStaticBrushIterator It(InWorld); It; ++It)
    {
        ABrush* Brush = CastChecked<ABrush>(*It);
        if (!FActorEditorUtils::IsABuilderBrush(Brush))
        {
            if (!(Brush->PolyFlags & PF_Semisolid) || (Brush->BrushType != Brush_Add) || (Brush->PolyFlags & PF_Portal))
            {
                // Treat portals as solids for cutting.
                if (Brush->PolyFlags & PF_Portal)
                {
                    Brush->PolyFlags = (Brush->PolyFlags & ~PF_Semisolid) | PF_NotSolid;
                }
                BrushCount++;

                FFormatNamedArguments Args;
                Args.Add(TEXT("BrushCount"), BrushCount);
                Args.Add(TEXT("BrushTotal"), BrushTotal);
                GWarn->StatusUpdate(BrushCount, BrushTotal, FText::Format(NSLOCTEXT("UnrealEd", "ApplyingStructuralBrushF", "Applying structural brush {BrushCount} of {BrushTotal}"), Args));

                Brush->Modify();
                bspBrushCSG(Brush, InWorld->GetModel(), Brush->PolyFlags, (EBrushType)Brush->BrushType, CSG_None, false, true, false);
            }
        }
    }

    // Repartition the structural BSP.
    {
        GWarn->StatusUpdate(0, 4, NSLOCTEXT("UnrealEd", "RebuildBSPBuildingPolygons", "Rebuild BSP: Building polygons"));
        bspBuildFPolys(InWorld->GetModel(), 0, 0);

        GWarn->StatusUpdate(1, 4, NSLOCTEXT("UnrealEd", "RebuildBSPMergingPlanars", "Rebuild BSP: Merging planars"));
        bspMergeCoplanars(InWorld->GetModel(), 0, 0);

        GWarn->StatusUpdate(2, 4, NSLOCTEXT("UnrealEd", "RebuildBSPPartitioning", "Rebuild BSP: Partitioning"));
        FBSPOps::bspBuild(InWorld->GetModel(), FBSPOps::BSP_Optimal, 15, 70, 0, 0);

        GWarn->UpdateProgress(4, 4);
    }

    // Remember leaves.
    TArray<int32> iFronts, iBacks;
    if (InWorld->GetModel()->Nodes.Num())
    {
        EnlistLeaves(InWorld->GetModel(), iFronts, iBacks, 0);
    }

    // Compose all detail brushes.
    for (FStaticBrushIterator It(InWorld); It; ++It)
    {
        ABrush* Brush = CastChecked<ABrush>(*It);
        if (!FActorEditorUtils::IsABuilderBrush(Brush) && (Brush->PolyFlags & PF_Semisolid) && !(Brush->PolyFlags & PF_Portal) && Brush->BrushType == Brush_Add)
        {
            BrushCount++;

            FFormatNamedArguments Args;
            Args.Add(TEXT("BrushCount"), BrushCount);
            Args.Add(TEXT("BrushTotal"), BrushTotal);
            GWarn->StatusUpdate(BrushCount, BrushTotal, FText::Format(NSLOCTEXT("UnrealEd", "ApplyingDetailBrushF", "Applying detail brush {BrushCount} of {BrushTotal}"), Args));

            Brush->Modify();
            bspBrushCSG(Brush, InWorld->GetModel(), Brush->PolyFlags, (EBrushType)Brush->BrushType, CSG_None, false, true, false);
        }
    }

    // Optimize the sub-bsp's.
    GWarn->StatusUpdate(0, 4, NSLOCTEXT("UnrealEd", "RebuildCSGOptimizingSubBSPs", "Rebuild CSG: Optimizing Sub-BSPs"));
    int32 iNode;
    for (TArray<int32>::TIterator ItF(iFronts); ItF; ++ItF)
    {
        if ((iNode = InWorld->GetModel()->Nodes[*ItF].iFront) != INDEX_NONE)
        {
            bspRepartition(InWorld, iNode);
        }
    }
    for (TArray<int32>::TIterator ItB(iBacks); ItB; ++ItB)
    {
        if ((iNode = InWorld->GetModel()->Nodes[*ItB].iBack) != INDEX_NONE)
        {
            bspRepartition(InWorld, iNode);
        }
    }

    GWarn->StatusUpdate(1, 4, NSLOCTEXT("UnrealEd", "RebuildBSPOptimizingGeometry", "Rebuild BSP: Optimizing geometry"));
    bspOptGeom(InWorld->GetModel());

    // Build bounding volumes.
    GWarn->StatusUpdate(2, 4, NSLOCTEXT("UnrealEd", "RebuildCSGBuildingBoundingVolumes", "Rebuild CSG: Building Bounding Volumes"));
    FBSPOps::bspBuildBounds(InWorld->GetModel());

    // Rebuild dynamic brush BSP's.
    GWarn->StatusUpdate(3, 4, NSLOCTEXT("UnrealEd", "RebuildCSGRebuildingDynamicBrushBSPs", "Rebuild CSG: Rebuilding Dynamic Brush BSPs"));

    TArray<ABrush*> DynamicBrushes;
    DynamicBrushes.Empty();
    for (TActorIterator<ABrush> It(InWorld); It; ++It)
    {
        ABrush* B = *It;
        if (B && B->GetLevel() == InWorld->GetCurrentLevel() && B->Brush && !B->IsStaticBrush())
        {
            DynamicBrushes.Add(B);
        }
    }

    {
        FScopedSlowTask SlowTask(DynamicBrushes.Num(), NSLOCTEXT("UnrealEd", "RebuildCSGRebuildingDynamicBrushBSPs", "Rebuild CSG: Rebuilding Dynamic Brush BSPs"));
        for (int32 BrushIndex = 0; BrushIndex < DynamicBrushes.Num(); BrushIndex++)
        {
            SlowTask.EnterProgressFrame();

            ABrush* B = DynamicBrushes[BrushIndex];
            FBSPOps::csgPrepMovingBrush(B);

            if (GEngine->GetMapBuildCancelled())
            {
                break;
            }
        }
    }

    GWarn->UpdateProgress(4, 4);

    // update static navigable geometry in current level
    RebuildStaticNavigableGeometry(InWorld->GetCurrentLevel());

    // Empty EdPolys.
    InWorld->GetModel()->Polys->Element.Empty();

    // Done.
    ABrush::GGeometryRebuildCause = nullptr;
    FBSPOps::GFastRebuild         = 0;
    InWorld->GetCurrentLevel()->MarkPackageDirty();
    GWarn->EndSlowTask();
}

void UEditorEngine::polySetAndClearPolyFlags(UModel* Model, uint32 SetBits, uint32 ClearBits, bool SelectedOnly, bool UpdateMaster)
{
    for (int32 i = 0; i < Model->Surfs.Num(); i++)
    {
        FBspSurf& Poly = Model->Surfs[i];
        if (!SelectedOnly || (Poly.PolyFlags & PF_Selected))
        {
            uint32 NewFlags = (Poly.PolyFlags & ~ClearBits) | SetBits;
            if (NewFlags != Poly.PolyFlags)
            {
                Model->ModifySurf(i, UpdateMaster);
                Poly.PolyFlags = NewFlags;
                if (UpdateMaster)
                {
                    const bool bUpdateTexCoords             = false;
                    const bool bOnlyRefreshSurfaceMaterials = false;
                    polyUpdateMaster(Model, i, bUpdateTexCoords, bOnlyRefreshSurfaceMaterials);
                }
            }
        }
    }
}

bool UEditorEngine::polyFindMaster(UModel* InModel, int32 iSurf, FPoly& Poly)
{
    FBspSurf& Surf = InModel->Surfs[iSurf];
    if (!Surf.Actor || !Surf.Actor->Brush->Polys->Element.IsValidIndex(Surf.iBrushPoly))
    {
        return false;
    }
    else
    {
        Poly = Surf.Actor->Brush->Polys->Element[Surf.iBrushPoly];
        return true;
    }
}

void UEditorEngine::polyUpdateMaster(
    UModel* Model,
    int32 iSurf,
    bool bUpdateTexCoords,
    bool bOnlyRefreshSurfaceMaterials)
{
    FBspSurf& Surf = Model->Surfs[iSurf];
    ABrush* Actor  = Surf.Actor;
    if (!Actor)
        return;

    UModel* Brush = Actor->Brush;
    check(Brush);

    FVector ActorLocation;
    FVector ActorPrePivot;
    FVector ActorScale;
    FRotator ActorRotation;

    if (Brush->bCachedOwnerTransformValid)
    {
        // Use transform cached when the geometry was last built, in case the current Actor transform has changed since then
        // (e.g. because Auto Update BSP is disabled)
        ActorLocation = Brush->OwnerLocationWhenLastBuilt;
        ActorScale    = Brush->OwnerScaleWhenLastBuilt;
        ActorRotation = Brush->OwnerRotationWhenLastBuilt;
    }
    else
    {
        // No cached owner transform, so use the current one
        ActorLocation = Actor->GetActorLocation();
        ActorScale    = Actor->GetActorScale();
        ActorRotation = Actor->GetActorRotation();
    }

    const FRotationMatrix RotationMatrix(ActorRotation);

    for (int32 iEdPoly = Surf.iBrushPoly; iEdPoly < Brush->Polys->Element.Num(); iEdPoly++)
    {
        FPoly& MasterEdPoly = Brush->Polys->Element[iEdPoly];
        if (iEdPoly == Surf.iBrushPoly || MasterEdPoly.iLink == Surf.iBrushPoly)
        {
            MasterEdPoly.Material  = Surf.Material;
            MasterEdPoly.PolyFlags = Surf.PolyFlags & ~(PF_NoEdit);

            if (bUpdateTexCoords)
            {
                MasterEdPoly.Base     = RotationMatrix.InverseTransformVector(Model->Points[Surf.pBase] - ActorLocation) / ActorScale;
                MasterEdPoly.TextureU = RotationMatrix.InverseTransformVector(Model->Vectors[Surf.vTextureU]) * ActorScale;
                MasterEdPoly.TextureV = RotationMatrix.InverseTransformVector(Model->Vectors[Surf.vTextureV]) * ActorScale;
            }
        }
    }

    Model->InvalidSurfaces = true;

    if (bOnlyRefreshSurfaceMaterials)
    {
        Model->bOnlyRebuildMaterialIndexBuffers = true;
    }
}

void UEditorEngine::polyGetLinkedPolys(
    ABrush* InBrush,
    FPoly* InPoly,
    TArray<FPoly>* InPolyList)
{
    InPolyList->Empty();

    if (InPoly->iLink == INDEX_NONE)
    {
        // If this poly has no links, just stick the one poly in the final list.
        new (*InPolyList) FPoly(*InPoly);
    }
    else
    {
        // Find all polys that match the source polys link value.
        for (int32 poly = 0; poly < InBrush->Brush->Polys->Element.Num(); poly++)
            if (InBrush->Brush->Polys->Element[poly].iLink == InPoly->iLink)
                new (*InPolyList) FPoly(InBrush->Brush->Polys->Element[poly]);
    }
}

void UEditorEngine::polySplitOverlappingEdges(TArray<FPoly>* InPolyList, TArray<FPoly>* InResult)
{
    InResult->Empty();

    for (int32 poly = 0; poly < InPolyList->Num(); poly++)
    {
        FPoly* SrcPoly = &(*InPolyList)[poly];
        FPoly NewPoly  = *SrcPoly;

        for (int32 edge = 0; edge < SrcPoly->Vertices.Num(); edge++)
        {
            FEdge SrcEdge = FEdge(SrcPoly->Vertices[edge], SrcPoly->Vertices[edge + 1 < SrcPoly->Vertices.Num() ? edge + 1 : 0]);
            FPlane SrcEdgePlane(SrcEdge.Vertex[0], SrcEdge.Vertex[1], SrcEdge.Vertex[0] + (SrcPoly->Normal * 16));

            for (int32 poly2 = 0; poly2 < InPolyList->Num(); poly2++)
            {
                FPoly* CmpPoly = &(*InPolyList)[poly2];

                // We can't compare to ourselves.
                if (CmpPoly == SrcPoly)
                    continue;

                for (int32 edge2 = 0; edge2 < CmpPoly->Vertices.Num(); edge2++)
                {
                    FEdge CmpEdge = FEdge(CmpPoly->Vertices[edge2], CmpPoly->Vertices[edge2 + 1 < CmpPoly->Vertices.Num() ? edge2 + 1 : 0]);

                    // If both vertices on this edge lie on the same plane as the original edge, create
                    // a sphere around the original 2 vertices.  If either of this edges vertices are inside of
                    // that sphere, we need to split the original edge by adding a vertex to it's poly.
                    if (FMath::Abs(FVector::PointPlaneDist(CmpEdge.Vertex[0], SrcEdge.Vertex[0], SrcEdgePlane)) < THRESH_POINT_ON_PLANE && FMath::Abs(FVector::PointPlaneDist(CmpEdge.Vertex[1], SrcEdge.Vertex[0], SrcEdgePlane)) < THRESH_POINT_ON_PLANE)
                    {
                        //
                        // Check THIS edge against the SOURCE edge
                        //

                        FVector Dir = SrcEdge.Vertex[1] - SrcEdge.Vertex[0];
                        Dir.Normalize();
                        float Dist     = FVector::Dist(SrcEdge.Vertex[1], SrcEdge.Vertex[0]);
                        FVector Origin = SrcEdge.Vertex[0] + (Dir * (Dist / 2.0f));
                        float Radius   = Dist / 2.0f;

                        for (int32 vtx = 0; vtx < 2; vtx++)
                            if (FVector::Dist(Origin, CmpEdge.Vertex[vtx]) && FVector::Dist(Origin, CmpEdge.Vertex[vtx]) < Radius)
                                NewPoly.InsertVertex(edge2 + 1, CmpEdge.Vertex[vtx]);
                    }
                }
            }
        }

        new (*InResult) FPoly(NewPoly);
    }
}

void UEditorEngine::polyGetOuterEdgeList(
    TArray<FPoly>* InPolyList,
    TArray<FEdge>* InEdgeList)
{
    TArray<FPoly> NewPolyList;
    polySplitOverlappingEdges(InPolyList, &NewPolyList);

    TArray<FEdge> TempEdges;

    // Create a master list of edges.
    for (int32 poly = 0; poly < NewPolyList.Num(); poly++)
    {
        FPoly* Poly = &NewPolyList[poly];
        for (int32 vtx = 0; vtx < Poly->Vertices.Num(); vtx++)
            new (TempEdges) FEdge(Poly->Vertices[vtx], Poly->Vertices[vtx + 1 < Poly->Vertices.Num() ? vtx + 1 : 0]);
    }

    // Add all the unique edges into the final edge list.
    TArray<FEdge> FinalEdges;

    for (int32 tedge = 0; tedge < TempEdges.Num(); tedge++)
    {
        FEdge* TestEdge = &TempEdges[tedge];

        int32 EdgeCount = 0;
        for (int32 edge = 0; edge < TempEdges.Num(); edge++)
        {
            if (TempEdges[edge] == *TestEdge)
                EdgeCount++;
        }

        if (EdgeCount == 1)
            new (FinalEdges) FEdge(*TestEdge);
    }

    // Reorder all the edges so that they line up, end to end.
    InEdgeList->Empty();
    if (!FinalEdges.Num())
        return;

    new (*InEdgeList) FEdge(FinalEdges[0]);
    FVector Comp = FinalEdges[0].Vertex[1];
    FinalEdges.RemoveAt(0);

    FEdge DebuG;
    for (int32 x = 0; x < FinalEdges.Num(); x++)
    {
        DebuG = FinalEdges[x];

        // If the edge is backwards, flip it
        if (FinalEdges[x].Vertex[1] == Comp)
            Exchange(FinalEdges[x].Vertex[0], FinalEdges[x].Vertex[1]);

        if (FinalEdges[x].Vertex[0] == Comp)
        {
            new (*InEdgeList) FEdge(FinalEdges[x]);
            Comp = FinalEdges[x].Vertex[1];
            FinalEdges.RemoveAt(x);
            x = -1;
        }
    }
}

/*-----------------------------------------------------------------------------
   All transactional polygon selection functions
-----------------------------------------------------------------------------*/

/**
 * Generates a list of brushes corresponding to the set of selected surfaces for the specified model.
 */
static void GetListOfUniqueBrushes(TArray<ABrush*>* InBrushes, UModel* Model)
{
    InBrushes->Empty();

    // Generate a list of unique brushes.
    for (int32 i = 0; i < Model->Surfs.Num(); i++)
    {
        FBspSurf* Surf = &Model->Surfs[i];
        if (Surf->PolyFlags & PF_Selected)
        {
            if (Surf->Actor)
            {
                // See if we've already got this brush ...
                int32 brush;
                for (brush = 0; brush < InBrushes->Num(); brush++)
                {
                    if (Surf->Actor == (*InBrushes)[brush])
                    {
                        break;
                    }
                }

                // ... if not, add it to the list.
                if (brush == InBrushes->Num())
                {
                    (*InBrushes)[InBrushes->AddUninitialized()] = Surf->Actor;
                }
            }
        }
    }
}

void UEditorEngine::polySelectAll(UModel* Model)
{
    polySetAndClearPolyFlags(Model, PF_Selected, 0, 0, 0);
}

void UEditorEngine::polySelectMatchingGroups(UModel* Model)
{
    // @hack: polySelectMatchingGroups: do nothing for now as temp fix until this can be rewritten (crashes a lot)
#if 0
	FMemory::Memzero( GFlags1, sizeof(GFlags1) );
	for( int32 i=0; i<Model->Surfs.Num(); i++ )
	{
		FBspSurf *Surf = &Model->Surfs(i);
		if( Surf->PolyFlags&PF_Selected )
		{
			FPoly Poly; polyFindMaster(Model,i,Poly);
			GFlags1[Poly.Actor->Layer.GetIndex()]=1;
		}
	}
	for( int32 i=0; i<Model->Surfs.Num(); i++ )
	{
		FBspSurf *Surf = &Model->Surfs(i);
		FPoly Poly;
		polyFindMaster(Model,i,Poly);
		if
		(	(GFlags1[Poly.Actor->Layer.GetIndex()]) 
			&&	(!(Surf->PolyFlags & PF_Selected)) )
		{
			Model->ModifySurf( i, 0 );
			GEditor->SelectBSPSurf( Model, i, true, false );
		}
	}
	NoteSelectionChange();
#endif
}

void UEditorEngine::polySelectMatchingItems(UModel* InModel)
{
#if 0
	FMemory::Memzero(GFlags1,sizeof(GFlags1));
	FMemory::Memzero(GFlags2,sizeof(GFlags2));

	for( int32 i=0; i<InModel->Surfs.Num(); i++ )
	{
		FBspSurf *Surf = &InModel->Surfs(i);
		if( Surf->Actor )
		{
			if( Surf->PolyFlags & PF_Selected )
				GFlags2[Surf->Actor->Brush->GetIndex()]=1;
		}
		if( Surf->PolyFlags&PF_Selected )
		{
			FPoly Poly; polyFindMaster(InModel,i,Poly);
			GFlags1[Poly.ItemName.GetIndex()]=1;
		}
	}
	for( int32 i=0; i<InModel->Surfs.Num(); i++ )
	{
		FBspSurf *Surf = &InModel->Surfs(i);
		if( Surf->Actor )
		{
			FPoly Poly; polyFindMaster(InModel,i,Poly);
			if ((GFlags1[Poly.ItemName.GetIndex()]) &&
				( GFlags2[Surf->Actor->Brush->GetIndex()]) &&
				(!(Surf->PolyFlags & PF_Selected)))
			{
				InModel->ModifySurf( i, 0 );
				GEditor->SelectBSPSurf( InModel, i, true, false );
			}
		}
	}
	NoteSelectionChange();
#endif
}

enum EAdjacentsType
{
    ADJACENT_ALL,        // All adjacent polys
    ADJACENT_COPLANARS,  // Adjacent coplanars only
    ADJACENT_WALLS,      // Adjacent walls
    ADJACENT_FLOORS,     // Adjacent floors or ceilings
    ADJACENT_SLANTS,     // Adjacent slants
};

/**
 * Selects all adjacent polygons (only coplanars if Coplanars==1)
 * @return		Number of polygons newly selected.
 */
static int32 TagAdjacentsType(UWorld* InWorld, EAdjacentsType AdjacentType)
{
    // Allocate GFlags1
    check(GFlags1.Num() == 0);
    for (FConstLevelIterator Iterator = InWorld->GetLevelIterator(); Iterator; ++Iterator)
    {
        UModel* Model = (*Iterator)->Model;
        uint8* Ptr    = new uint8[MAX_uint16 + 1];
        FMemory::Memzero(Ptr, MAX_uint16 + 1);
        GFlags1.Add(Ptr);
    }

    FVert* VertPool;
    FVector *Base, *Normal;
    uint8 b;
    int32 i;
    int Selected, Found;

    Selected = 0;

    // Find all points corresponding to selected vertices:
    int32 ModelIndex1 = 0;
    for (FConstLevelIterator Iterator = InWorld->GetLevelIterator(); Iterator; ++Iterator)
    {
        UModel* Model = (*Iterator)->Model;
        uint8* Flags1 = GFlags1[ModelIndex1++];
        for (i = 0; i < Model->Nodes.Num(); i++)
        {
            FBspNode& Node = Model->Nodes[i];
            FBspSurf& Poly = Model->Surfs[Node.iSurf];
            if (Poly.PolyFlags & PF_Selected)
            {
                VertPool = &Model->Verts[Node.iVertPool];
                for (b = 0; b < Node.NumVertices; b++)
                {
                    Flags1[(VertPool++)->pVertex] = 1;
                }
            }
        }
    }

    // Select all unselected nodes for which two or more vertices are selected:
    ModelIndex1       = 0;
    int32 ModelIndex2 = -1;
    for (FConstLevelIterator Iterator = InWorld->GetLevelIterator(); Iterator; ++Iterator)
    {
        UModel* Model = (*Iterator)->Model;
        uint8* Flags1 = GFlags1[ModelIndex1];
        ModelIndex1++;
        ModelIndex2++;
        for (i = 0; i < Model->Nodes.Num(); i++)
        {
            FBspNode& Node = Model->Nodes[i];
            FBspSurf& Poly = Model->Surfs[Node.iSurf];
            if (!(Poly.PolyFlags & PF_Selected))
            {
                Found    = 0;
                VertPool = &Model->Verts[Node.iVertPool];
                //
                Base   = &Model->Points[Poly.pBase];
                Normal = &Model->Vectors[Poly.vNormal];
                //
                for (b = 0; b < Node.NumVertices; b++)
                    Found += Flags1[(VertPool++)->pVertex];
                //
                if (AdjacentType == ADJACENT_COPLANARS)
                {
                    if (!GFlags2[ModelIndex2][Node.iSurf])
                        Found = 0;
                }
                else if (AdjacentType == ADJACENT_FLOORS)
                {
                    if (FMath::Abs(Normal->Z) <= 0.85)
                        Found = 0;
                }
                else if (AdjacentType == ADJACENT_WALLS)
                {
                    if (FMath::Abs(Normal->Z) >= 0.10)
                        Found = 0;
                }
                else if (AdjacentType == ADJACENT_SLANTS)
                {
                    if (FMath::Abs(Normal->Z) > 0.85)
                        Found = 0;
                    if (FMath::Abs(Normal->Z) < 0.10)
                        Found = 0;
                }

                if (Found > 0)
                {
                    Model->ModifySurf(Node.iSurf, 0);
                    GEditor->SelectBSPSurf(Model, Node.iSurf, true, false);
                    Selected++;
                }
            }
        }
    }

    // Free GFlags1.
    for (i = 0; i < GFlags1.Num(); ++i)
    {
        delete[] GFlags1[i];
    }
    GFlags1.Empty();

    GEditor->NoteSelectionChange();
    return Selected;
}

void UEditorEngine::polySelectAdjacents(UWorld* InWorld, UModel* InModel)
{
    do
    {
    } while (TagAdjacentsType(InWorld, ADJACENT_ALL) > 0);
}

void UEditorEngine::polySelectCoplanars(UWorld* InWorld, UModel* InModel)
{
    // Allocate GFlags2
    check(GFlags2.Num() == 0);
    for (FConstLevelIterator Iterator = InWorld->GetLevelIterator(); Iterator; ++Iterator)
    {
        UModel* Model = (*Iterator)->Model;
        uint8* Ptr    = new uint8[MAX_uint16 + 1];
        FMemory::Memzero(Ptr, MAX_uint16 + 1);
        GFlags2.Add(Ptr);
    }

    /////////////
    // Tag coplanars.

    int32 ModelIndex = 0;
    for (FConstLevelIterator Iterator = InWorld->GetLevelIterator(); Iterator; ++Iterator)
    {
        UModel* Model = (*Iterator)->Model;
        uint8* Flags2 = GFlags2[ModelIndex++];
        for (int32 SelectedNodeIndex = 0; SelectedNodeIndex < Model->Nodes.Num(); SelectedNodeIndex++)
        {
            FBspNode& SelectedNode = Model->Nodes[SelectedNodeIndex];
            FBspSurf& SelectedSurf = Model->Surfs[SelectedNode.iSurf];

            if (SelectedSurf.PolyFlags & PF_Selected)
            {
                const FVector SelectedBase   = Model->Points[Model->Verts[SelectedNode.iVertPool].pVertex];
                const FVector SelectedNormal = Model->Vectors[SelectedSurf.vNormal];

                for (int32 NodeIndex = 0; NodeIndex < Model->Nodes.Num(); NodeIndex++)
                {
                    FBspNode& Node                   = Model->Nodes[NodeIndex];
                    FBspSurf& Surf                   = Model->Surfs[Node.iSurf];
                    const FVector Base               = Model->Points[Model->Verts[Node.iVertPool].pVertex];
                    const FVector Normal             = Model->Vectors[Surf.vNormal];

                    const float ParallelDotThreshold = 0.98f;  // roughly 11.4 degrees (!), but this is the long-standing behavior.
                    if (FVector::Coincident(SelectedNormal, Normal, ParallelDotThreshold) &&
                        FVector::Coplanar(SelectedBase, SelectedNormal, Base, Normal, ParallelDotThreshold) && !(Surf.PolyFlags & PF_Selected))
                    {
                        Flags2[Node.iSurf] = 1;
                    }
                }
            }
        }
    }

    do
    {
    } while (TagAdjacentsType(InWorld, ADJACENT_COPLANARS) > 0);

    // Free GFlags2
    for (int32 i = 0; i < GFlags2.Num(); ++i)
    {
        delete[] GFlags2[i];
    }
    GFlags2.Empty();
}

void UEditorEngine::polySelectMatchingBrush(UModel* InModel)
{
    TArray<ABrush*> Brushes;
    GetListOfUniqueBrushes(&Brushes, InModel);

    // Select all the faces.
    for (int32 i = 0; i < InModel->Surfs.Num(); i++)
    {
        FBspSurf* Surf = &InModel->Surfs[i];
        if (Surf->Actor)
        {
            // Select all the polys on each brush in the unique list.
            for (int32 brush = 0; brush < Brushes.Num(); brush++)
            {
                ABrush* CurBrush = Brushes[brush];
                if (Surf->Actor == CurBrush)
                {
                    for (int32 poly = 0; poly < CurBrush->Brush->Polys->Element.Num(); poly++)
                    {
                        if (Surf->iBrushPoly == poly)
                        {
                            InModel->ModifySurf(i, 0);
                            GEditor->SelectBSPSurf(InModel, i, true, false);
                        }
                    }
                }
            }
        }
    }
    NoteSelectionChange();
}

void UEditorEngine::polySelectMatchingMaterial(UWorld* InWorld, bool bCurrentLevelOnly)
{
    // true if at least one surface was selected.
    bool bSurfaceWasSelected = false;

    // true if default material representations have already been added to the materials list.
    bool bDefaultMaterialAdded = false;

    TArray<UMaterialInterface*> Materials;

    if (bCurrentLevelOnly)
    {
        // Get list of unique materials that are on selected faces.
        for (TSelectedSurfaceIterator<FCurrentLevelSurfaceLevelFilter> It(InWorld); It; ++It)
        {
            if (It->Material && It->Material != UMaterial::GetDefaultMaterial(MD_Surface))
            {
                Materials.AddUnique(It->Material);
            }
            else if (!bDefaultMaterialAdded)
            {
                bDefaultMaterialAdded = true;

                // Add both representations of the default material.
                Materials.AddUnique(NULL);
                Materials.AddUnique(UMaterial::GetDefaultMaterial(MD_Surface));
            }
        }

        // Select all surfaces with matching materials.
        for (TSurfaceIterator<FCurrentLevelSurfaceLevelFilter> It(InWorld); It; ++It)
        {
            // Map the default material to NULL, so that NULL assignments match manual default material assignments.
            if (Materials.Contains(It->Material))
            {
                UModel* Model            = It.GetModel();
                const int32 SurfaceIndex = It.GetSurfaceIndex();
                Model->ModifySurf(SurfaceIndex, 0);
                GEditor->SelectBSPSurf(Model, SurfaceIndex, true, false);
                bSurfaceWasSelected = true;
            }
        }
    }
    else
    {
        // Get list of unique materials that are on selected faces.
        for (TSelectedSurfaceIterator<> It(InWorld); It; ++It)
        {
            if (It->Material && It->Material != UMaterial::GetDefaultMaterial(MD_Surface))
            {
                Materials.AddUnique(It->Material);
            }
            else if (!bDefaultMaterialAdded)
            {
                bDefaultMaterialAdded = true;

                // Add both representations of the default material.
                Materials.AddUnique(NULL);
                Materials.AddUnique(UMaterial::GetDefaultMaterial(MD_Surface));
            }
        }

        // Select all surfaces with matching materials.
        for (TSurfaceIterator<> It(InWorld); It; ++It)
        {
            // Map the default material to NULL, so that NULL assignments match manual default material assignments.
            if (Materials.Contains(It->Material))
            {
                UModel* Model            = It.GetModel();
                const int32 SurfaceIndex = It.GetSurfaceIndex();
                Model->ModifySurf(SurfaceIndex, 0);
                GEditor->SelectBSPSurf(Model, SurfaceIndex, true, false);
                bSurfaceWasSelected = true;
            }
        }
    }

    if (bSurfaceWasSelected)
    {
        NoteSelectionChange();
    }
}

void UEditorEngine::polySelectMatchingResolution(UWorld* InWorld, bool bCurrentLevelOnly)
{
    // true if at least one surface was selected.
    bool bSurfaceWasSelected = false;

    TArray<float> SelectedResolutions;

    if (bCurrentLevelOnly == true)
    {
        for (TSelectedSurfaceIterator<FCurrentLevelSurfaceLevelFilter> It(InWorld); It; ++It)
        {
            SelectedResolutions.AddUnique(It->LightMapScale);
        }

        if (SelectedResolutions.Num() > 0)
        {
            if (SelectedResolutions.Num() > 1)
            {
                FMessageDialog::Open(EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "BSPSelect_DifferentResolutionsSelected", "Different selected resolutions.\nCan only select matching for a single resolution."));
            }
            else
            {
                // Select all surfaces with matching materials.
                for (TSurfaceIterator<FCurrentLevelSurfaceLevelFilter> It(InWorld); It; ++It)
                {
                    if (SelectedResolutions.Contains(It->LightMapScale))
                    {
                        UModel* Model            = It.GetModel();
                        const int32 SurfaceIndex = It.GetSurfaceIndex();
                        Model->ModifySurf(SurfaceIndex, 0);
                        GEditor->SelectBSPSurf(Model, SurfaceIndex, true, false);
                        bSurfaceWasSelected = true;
                    }
                }
            }
        }
    }
    else
    {
        for (TSelectedSurfaceIterator<> It(InWorld); It; ++It)
        {
            SelectedResolutions.AddUnique(It->LightMapScale);
        }

        if (SelectedResolutions.Num() > 0)
        {
            if (SelectedResolutions.Num() > 1)
            {
                FMessageDialog::Open(EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "BSPSelect_DifferentResolutionsSelected", "Different selected resolutions.\nCan only select matching for a single resolution."));
            }
            else
            {
                // Select all surfaces with matching materials.
                for (TSurfaceIterator<> It(InWorld); It; ++It)
                {
                    if (SelectedResolutions.Contains(It->LightMapScale))
                    {
                        UModel* Model            = It.GetModel();
                        const int32 SurfaceIndex = It.GetSurfaceIndex();
                        Model->ModifySurf(SurfaceIndex, 0);
                        GEditor->SelectBSPSurf(Model, SurfaceIndex, true, false);
                        bSurfaceWasSelected = true;
                    }
                }
            }
        }
    }

    if (bSurfaceWasSelected)
    {
        NoteSelectionChange();
    }
}

void UEditorEngine::polySelectAdjacentWalls(UWorld* InWorld, UModel* InModel)
{
    do
    {
    } while (TagAdjacentsType(InWorld, ADJACENT_WALLS) > 0);
}

void UEditorEngine::polySelectAdjacentFloors(UWorld* InWorld, UModel* InModel)
{
    do
    {
    } while (TagAdjacentsType(InWorld, ADJACENT_FLOORS) > 0);
}

void UEditorEngine::polySelectAdjacentSlants(UWorld* InWorld, UModel* InModel)
{
    do
    {
    } while (TagAdjacentsType(InWorld, ADJACENT_SLANTS) > 0);
}

void UEditorEngine::polySelectReverse(UModel* InModel)
{
    for (int32 i = 0; i < InModel->Surfs.Num(); i++)
    {
        FBspSurf* Poly = &InModel->Surfs[i];
        InModel->ModifySurf(i, 0);
        Poly->PolyFlags ^= PF_Selected;
    }
}

void UEditorEngine::polyMemorizeSet(UModel* InModel)
{
    for (int32 i = 0; i < InModel->Surfs.Num(); i++)
    {
        FBspSurf* Poly = &InModel->Surfs[i];
        if (Poly->PolyFlags & PF_Selected)
        {
            if (!(Poly->PolyFlags & PF_Memorized))
            {
                InModel->ModifySurf(i, 0);
                Poly->PolyFlags |= (PF_Memorized);
            }
        }
        else
        {
            if (Poly->PolyFlags & PF_Memorized)
            {
                InModel->ModifySurf(i, 0);
                Poly->PolyFlags &= (~PF_Memorized);
            }
        }
    }
}

void UEditorEngine::polyRememberSet(UModel* InModel)
{
    for (int32 i = 0; i < InModel->Surfs.Num(); i++)
    {
        FBspSurf* Poly = &InModel->Surfs[i];
        if (Poly->PolyFlags & PF_Memorized)
        {
            if (!(Poly->PolyFlags & PF_Selected))
            {
                InModel->ModifySurf(i, 0);
                Poly->PolyFlags |= (PF_Selected);
            }
        }
        else
        {
            if (Poly->PolyFlags & PF_Selected)
            {
                InModel->ModifySurf(i, 0);
                Poly->PolyFlags &= (~PF_Selected);
            }
        }
    }
}

void UEditorEngine::polyXorSet(UModel* InModel)
{
    int Flag1, Flag2;
    //
    for (int32 i = 0; i < InModel->Surfs.Num(); i++)
    {
        FBspSurf* Poly = &InModel->Surfs[i];
        Flag1          = (Poly->PolyFlags & PF_Selected) != 0;
        Flag2          = (Poly->PolyFlags & PF_Memorized) != 0;
        //
        if (Flag1 ^ Flag2)
        {
            if (!(Poly->PolyFlags & PF_Selected))
            {
                InModel->ModifySurf(i, 0);
                Poly->PolyFlags |= PF_Selected;
            }
        }
        else
        {
            if (Poly->PolyFlags & PF_Selected)
            {
                InModel->ModifySurf(i, 0);
                Poly->PolyFlags &= (~PF_Selected);
            }
        }
    }
}

void UEditorEngine::polyUnionSet(UModel* InModel)
{
    for (int32 i = 0; i < InModel->Surfs.Num(); i++)
    {
        FBspSurf* Poly = &InModel->Surfs[i];
        if (!(Poly->PolyFlags & PF_Memorized))
        {
            if (Poly->PolyFlags & PF_Selected)
            {
                InModel->ModifySurf(i, 0);
                Poly->PolyFlags &= (~PF_Selected);
            }
        }
    }
}

void UEditorEngine::polyIntersectSet(UModel* InModel)
{
    for (int32 i = 0; i < InModel->Surfs.Num(); i++)
    {
        FBspSurf* Poly = &InModel->Surfs[i];
        if ((Poly->PolyFlags & PF_Memorized) && !(Poly->PolyFlags & PF_Selected))
        {
            InModel->ModifySurf(i, 0);
            Poly->PolyFlags |= PF_Selected;
        }
    }
}

void UEditorEngine::polySelectZone(UModel* InModel)
{
    // identify the list of currently selected zones
    TArray<int32> iZoneList;
    for (int32 i = 0; i < InModel->Nodes.Num(); i++)
    {
        FBspNode* Node = &InModel->Nodes[i];
        FBspSurf* Poly = &InModel->Surfs[Node->iSurf];
        if (Poly->PolyFlags & PF_Selected)
        {
            if (Node->iZone[1] != 0)
            {
                iZoneList.AddUnique(Node->iZone[1]);  // front zone
            }

            if (Node->iZone[0] != 0)
            {
                iZoneList.AddUnique(Node->iZone[0]);  // back zone
            }
        }
    }

    // select all polys that are match one of the zones identified above
    for (int32 i = 0; i < InModel->Nodes.Num(); i++)
    {
        FBspNode* Node = &InModel->Nodes[i];
        for (int32 j = 0; j < iZoneList.Num(); j++)
        {
            if (Node->iZone[1] == iZoneList[j] || Node->iZone[0] == iZoneList[j])
            {
                FBspSurf* Poly = &InModel->Surfs[Node->iSurf];
                InModel->ModifySurf(i, 0);
                Poly->PolyFlags |= PF_Selected;
            }
        }
    }
}

/*---------------------------------------------------------------------------------------
   Brush selection functions
---------------------------------------------------------------------------------------*/

//
// Generic selection routines
//

typedef int32 (*BRUSH_SEL_FUNC)(ABrush* Brush, int32 Tag);

static void MapSelect(UWorld* InWorld, BRUSH_SEL_FUNC Func, int32 Tag)
{
    for (FStaticBrushIterator It(InWorld); It; ++It)
    {
        ABrush* Brush = CastChecked<ABrush>(*It);
        if (Func(Brush, Tag))
        {
            GEditor->SelectActor(Brush, true, false);
        }
        else
        {
            GEditor->SelectActor(Brush, false, false);
        }
    }
}

/**
 * Selects no brushes.
 */
static int32 BrushSelectNoneFunc(ABrush* Actor, int32 Tag)
{
    return 0;
}

/**
 * Selects brushes by their CSG operation.
 */
static int32 BrushSelectOperationFunc(ABrush* Actor, int32 Tag)
{
    return ((EBrushType)Actor->BrushType == Tag) && !(Actor->PolyFlags & (PF_NotSolid | PF_Semisolid));
}
void UEditorEngine::MapSelectOperation(UWorld* InWorld, EBrushType BrushType)
{
    MapSelect(InWorld, BrushSelectOperationFunc, BrushType);
}

int32 BrushSelectFlagsFunc(ABrush* Actor, int32 Tag)
{
    return Actor->PolyFlags & Tag;
}
void UEditorEngine::MapSelectFlags(UWorld* InWorld, uint32 Flags)
{
    MapSelect(InWorld, BrushSelectFlagsFunc, (int)Flags);
}

void UEditorEngine::MapBrushGet(UWorld* InWorld)
{
    for (FSelectionIterator It(GEditor->GetSelectedActorIterator()); It; ++It)
    {
        AActor* Actor = static_cast<AActor*>(*It);
        checkSlow(Actor->IsA(AActor::StaticClass()));

        ABrush* BrushActor = Cast<ABrush>(Actor);
        if (BrushActor && !FActorEditorUtils::IsABuilderBrush(Actor))
        {
            check(BrushActor->GetWorld());
            ABrush* WorldBrush = BrushActor->GetWorld()->GetDefaultBrush();
            check(WorldBrush);
            WorldBrush->Modify();
            WorldBrush->Brush->Polys->Element = BrushActor->Brush->Polys->Element;
            WorldBrush->CopyPosRotScaleFrom(BrushActor);

            WorldBrush->ReregisterAllComponents();
            break;
        }
    }

    GEditor->SelectNone(false, true);
    GEditor->SelectActor(InWorld->GetDefaultBrush(), true, true);
}

void UEditorEngine::mapBrushPut()
{
    for (FSelectionIterator It(GEditor->GetSelectedActorIterator()); It; ++It)
    {
        AActor* Actor = static_cast<AActor*>(*It);
        checkSlow(Actor->IsA(AActor::StaticClass()));

        ABrush* BrushActor = Cast<ABrush>(Actor);
        if (BrushActor && !FActorEditorUtils::IsABuilderBrush(Actor))
        {
            check(BrushActor->GetWorld());
            ABrush* WorldBrush = BrushActor->GetWorld()->GetDefaultBrush();
            check(WorldBrush);

            BrushActor->Modify();
            BrushActor->Brush->Polys->Element = WorldBrush->Brush->Polys->Element;
            BrushActor->CopyPosRotScaleFrom(WorldBrush);
            BrushActor->SetNeedRebuild(BrushActor->GetLevel());

            WorldBrush->ReregisterAllComponents();

            GLevelEditorModeTools().UpdateInternalData();
        }
    }
}

//
// Generic private routine for send to front / send to back
//
static void SendTo(UWorld* InWorld, int32 bSendToFirst)
{
    ULevel* Level = InWorld->GetCurrentLevel();
    for (AActor* Actor: Level->Actors)
    {
        if (Actor)
        {
            Actor->Modify();
        }
    }

    // Fire ULevel::LevelDirtiedEvent when falling out of scope.
    FScopedLevelDirtied LevelDirtyCallback;

    //@todo locked levels - do we need to skip locked levels?
    // Partition.
    TArray<AActor*> Lists[2];
    for (int32 i = 2; i < Level->Actors.Num(); i++)
    {
        if (Level->Actors[i])
        {
            Lists[(Level->Actors[i]->IsSelected() ? 1 : 0) ^ bSendToFirst ^ 1].Add(Level->Actors[i]);
            Level->Actors[i]->MarkPackageDirty();
            LevelDirtyCallback.Request();
        }
    }

    // Refill.
    check(Level->Actors.Num() >= 2);
    Level->Actors.RemoveAt(2, Level->Actors.Num() - 2);
    for (int32 i = 0; i < 2; i++)
    {
        for (int32 j = 0; j < Lists[i].Num(); j++)
        {
            Level->Actors.Add(Lists[i][j]);
        }
    }
}

void UEditorEngine::mapSendToFirst(UWorld* InWorld)
{
    SendTo(InWorld, 0);
}

void UEditorEngine::mapSendToLast(UWorld* InWorld)
{
    SendTo(InWorld, 1);
}

void UEditorEngine::mapSendToSwap(UWorld* InWorld)
{
    int32 Count   = 0;
    ULevel* Level = InWorld->GetCurrentLevel();
    AActor** Actors[2];

    // Fire ULevel::LevelDirtiedEvent when falling out of scope.
    FScopedLevelDirtied LevelDirtyCallback;

    //@todo locked levels - skip for locked levels?
    for (int32 i = 2; i < Level->Actors.Num() && Count < 2; i++)
    {
        AActor*& Actor = Level->Actors[i];
        if (Actor && Actor->IsSelected())
        {
            Actors[Count] = &Actor;
            Count++;
            Actor->MarkPackageDirty();
            LevelDirtyCallback.Request();
        }
    }

    if (Count == 2)
    {
        for (AActor* Actor: InWorld->GetCurrentLevel()->Actors)
        {
            Actor->Modify();
        }
        Exchange(*Actors[0], *Actors[1]);
    }
}

void UEditorEngine::MapSetBrush(UWorld* InWorld, EMapSetBrushFlags PropertiesMask, uint16 BrushColor, FName GroupName, uint32 SetPolyFlags, uint32 ClearPolyFlags, uint32 BrushType, int32 DrawType)
{
    // Fire ULevel::LevelDirtiedEvent when falling out of scope.
    FScopedLevelDirtied LevelDirtyCallback;

    for (FStaticBrushIterator It(InWorld); It; ++It)
    {
        ABrush* Brush = CastChecked<ABrush>(*It);
        if (!FActorEditorUtils::IsABuilderBrush(Brush) && Brush->IsSelected())
        {
            if (PropertiesMask & MSB_PolyFlags)
            {
                Brush->Modify();
                Brush->PolyFlags = (Brush->PolyFlags & ~ClearPolyFlags) | SetPolyFlags;
                Brush->UpdateComponentTransforms();
                Brush->MarkPackageDirty();
                LevelDirtyCallback.Request();
            }
            if (PropertiesMask & MSB_BrushType)
            {
                Brush->Modify();
                Brush->BrushType = EBrushType(BrushType);
                Brush->UpdateComponentTransforms();
                Brush->MarkPackageDirty();
                LevelDirtyCallback.Request();
            }
        }
    }
}

void UEditorEngine::polyTexPan(UModel* Model, int32 PanU, int32 PanV, int32 Absolute)
{
    for (int32 SurfaceIndex = 0; SurfaceIndex < Model->Surfs.Num(); SurfaceIndex++)
    {
        const FBspSurf& Surf = Model->Surfs[SurfaceIndex];

        if (Surf.PolyFlags & PF_Selected)
        {
            if (Absolute)
            {
                Model->Points[Surf.pBase] = FVector::ZeroVector;
            }

            const FVector TextureU = Model->Vectors[Surf.vTextureU];
            const FVector TextureV = Model->Vectors[Surf.vTextureV];

            Model->Points[Surf.pBase] += PanU * (TextureU / TextureU.SizeSquared());
            Model->Points[Surf.pBase] += PanV * (TextureV / TextureV.SizeSquared());

            const bool bUpdateTexCoords             = true;
            const bool bOnlyRefreshSurfaceMaterials = true;
            polyUpdateMaster(Model, SurfaceIndex, bUpdateTexCoords, bOnlyRefreshSurfaceMaterials);
        }
    }
}

void UEditorEngine::polyTexScale(UModel* Model, float UU, float UV, float VU, float VV, bool Absolute)
{
    for (int32 i = 0; i < Model->Surfs.Num(); i++)
    {
        FBspSurf* Poly = &Model->Surfs[i];
        if (Poly->PolyFlags & PF_Selected)
        {
            FVector OriginalU = Model->Vectors[Poly->vTextureU];
            FVector OriginalV = Model->Vectors[Poly->vTextureV];

            if (Absolute)
            {
                OriginalU *= 1.0 / OriginalU.Size();
                OriginalV *= 1.0 / OriginalV.Size();
            }

            // Calc new vectors.
            Model->Vectors[Poly->vTextureU] = OriginalU * UU + OriginalV * UV;
            Model->Vectors[Poly->vTextureV] = OriginalU * VU + OriginalV * VV;

            // Update generating brush poly.
            const bool bUpdateTexCoords             = true;
            const bool bOnlyRefreshSurfaceMaterials = true;
            polyUpdateMaster(Model, i, bUpdateTexCoords, bOnlyRefreshSurfaceMaterials);
        }
    }
}