EditorUtilities.cpp

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "EditorUtilities.h"
 
#if WITH_EDITOR
#include "Editor/UnrealEdEngine.h"
#include "Editor.h"
#include "AssetToolsModule.h"
#include "ContentBrowserModule.h"
#include "IContentBrowserSingleton.h"
#include "ObjectTools.h"
#include "UObject/Package.h"
#include "TextureResource.h"
#include "Engine/Texture2D.h"
#include "AssetRegistry/AssetRegistryModule.h"
#include "AssetRegistry/AssetData.h"
#include "Modules/ModuleManager.h"
#include "UObject/SavePackage.h"
#include "HAL/UnrealMemory.h"
#endif
 
void UEditorUtilities::ExportThumbnailTextureFromSelectedAssets()
{
#if WITH_EDITOR
    // Access the selected assets in the Content Browser
    TArray<FAssetData> SelectedAssets;
    FContentBrowserModule& ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser"));
    IContentBrowserSingleton& ContentBrowserSingleton = ContentBrowserModule.Get();
    ContentBrowserSingleton.Get().GetSelectedAssets(SelectedAssets);
 
    for (const FAssetData& Asset : SelectedAssets)
    {
        CreateThumbnailTextureFromAsset(Asset);
    }
 
    UE_LOG(LogTemp, Warning, TEXT("EditorUtilities.cpp: Export complete."));
#endif
}
 
void UEditorUtilities::CreateThumbnailTextureFromAsset(const FAssetData& Asset)
{
#if WITH_EDITOR
    int32 pathSeparatorIdx;
    FAssetData obj = Asset;
    FString GamePath = obj.GetAsset()->GetPathName();
    FString AssetName;
    int32 pathEnd;
    if (GamePath.FindLastChar('/', pathEnd))
    {
        ++pathEnd;
        AssetName += GamePath;
        AssetName.RightChopInline(pathEnd);
        int32 extensionIdx;
        if (AssetName.FindChar('.', extensionIdx))
        {
            AssetName.LeftInline(extensionIdx);
            GamePath.LeftInline(pathEnd);
            FString Suffix = "T_";
            FString NameWithSuffix = Suffix + AssetName;
            AssetName = NameWithSuffix;
        }
        else
        {
            AssetName = "T_Thumbnail";
        }
 
        if (AssetName.FindChar('/', pathSeparatorIdx))
        {
            // TextureName should not have any path separators in it
            return;
        }
 
        FObjectThumbnail* thumb = ThumbnailTools::GenerateThumbnailForObjectToSaveToDisk(obj.GetAsset());
        if (!thumb)
        {
            return;
        }
 
        FString PackageName = TEXT("/Game/Agrarsense/Misc/ExportedThumbnailTextures/");
        if (!PackageName.EndsWith("/"))
        {
            PackageName += "/";
        }
        PackageName += AssetName;
 
        UPackage* Package = CreatePackage(*PackageName);
        Package->FullyLoad();
 
        UTexture2D* NewTexture = NewObject<UTexture2D>(Package, *AssetName, RF_Public | RF_Standalone | RF_MarkAsRootSet);
        NewTexture->AddToRoot();
        FTexturePlatformData* platformData = new FTexturePlatformData();
        platformData->SizeX = thumb->GetImageWidth();
        platformData->SizeY = thumb->GetImageHeight();
        //platformData->NumSlices = 1;
        platformData->PixelFormat = EPixelFormat::PF_B8G8R8A8;
        NewTexture->SetPlatformData(platformData);
 
        FTexture2DMipMap* Mip = new FTexture2DMipMap();
        platformData->Mips.Add(Mip);
        Mip->SizeX = thumb->GetImageWidth();
        Mip->SizeY = thumb->GetImageHeight();
 
        Mip->BulkData.Lock(LOCK_READ_WRITE);
        uint8* TextureData = (uint8*)Mip->BulkData.Realloc(thumb->GetUncompressedImageData().Num() * 4);
        FMemory::Memcpy(TextureData, thumb->GetUncompressedImageData().GetData(), thumb->GetUncompressedImageData().Num());
        Mip->BulkData.Unlock();
 
        NewTexture->Source.Init(thumb->GetImageWidth(), thumb->GetImageHeight(), 1, 1, ETextureSourceFormat::TSF_BGRA8, thumb->GetUncompressedImageData().GetData());
        NewTexture->LODGroup = TEXTUREGROUP_UI;
        NewTexture->UpdateResource();
        Package->MarkPackageDirty();
        Package->FullyLoad();
        FAssetRegistryModule::AssetCreated(NewTexture);
 
        FSavePackageArgs SaveArgs;
        SaveArgs.TopLevelFlags = EObjectFlags::RF_Public | EObjectFlags::RF_Standalone;
        SaveArgs.SaveFlags = SAVE_NoError;
        SaveArgs.bForceByteSwapping = true;
        FString PackageFileName = FPackageName::LongPackageNameToFilename(PackageName, FPackageName::GetAssetPackageExtension());
        UPackage::SavePackage(Package, NewTexture, *PackageFileName, SaveArgs);
    }
#endif
}
 
#include "Components/BoxComponent.h"
#if WITH_EDITOR
#include "Editor.h"
#include "EditorLevelUtils.h"
#include "ScopedTransaction.h"
#include "EngineUtils.h"
#include "Engine/Selection.h"
#include "Components/StaticMeshComponent.h"
#include "Landscape.h"
#include "LandscapeProxy.h"
#endif
 
void UEditorUtilities::DestroyOverlappingActorsWithMeshEditor(UBoxComponent* Area)
{
#if WITH_EDITOR
    if (!Area || !Area->GetWorld() || !Area->GetWorld()->IsEditorWorld())
    {
        return;
    }
 
    // Get the box world-space bounds
    const FTransform BoxTransform = Area->GetComponentTransform();
    const FVector BoxExtent = Area->GetScaledBoxExtent();
    const FVector BoxOrigin = BoxTransform.GetLocation();
    const FBox BoxBounds = FBox::BuildAABB(BoxOrigin, BoxExtent);
 
    const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "DeleteOverlappingActors", "Delete Overlapping Actors"));
 
    for (TActorIterator<AActor> It(Area->GetWorld()); It; ++It)
    {
        AActor* Actor = *It;
 
        if (!Actor || Actor == Area->GetOwner())
        {
            continue;
        }
 
        // Skip if landscape
        if (Actor->IsA<ALandscape>() || Actor->IsA<ALandscapeProxy>())
        {
            continue;
        }
 
        // Skip if no StaticMeshComponent
        bool bHasStaticMesh = false;
        TArray<UStaticMeshComponent*> StaticMeshComponents;
        Actor->GetComponents<UStaticMeshComponent>(StaticMeshComponents);
        for (UStaticMeshComponent* Comp : StaticMeshComponents)
        {
            if (Comp && Comp->GetStaticMesh())
            {
                bHasStaticMesh = true;
                break;
            }
        }
 
        if (!bHasStaticMesh)
        {
            continue;
        }
 
        const FBox ActorBounds = Actor->GetComponentsBoundingBox(true);
        if (BoxBounds.Intersect(ActorBounds))
        {
            Actor->Modify(); // For undo
            GEditor->GetEditorWorldContext().World()->DestroyActor(Actor, true, false);
        }
    }
#endif
}