AgrarsenseConsoleCommands.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 "AgrarsenseConsoleCommands.h"
#include "Agrarsense/Game/AgrarsenseStatics.h"
#include "Agrarsense/InstancedRendering/InstancedActor.h"
#include "Agrarsense/InstancedRendering/InstancedRenderer.h"
 
#include "Delegates/DelegateSignatureImpl.inl"
#include "Framework/Commands/UIAction.h"
#include "Engine/World.h"
#include "Engine/Engine.h"
#include "Engine/GameViewportClient.h"
 
#if WITH_EDITOR
#include "EngineUtils.h"
#include "Engine/World.h"
#include "Editor.h"
#endif
 
UAgrarsenseConsoleCommands::UAgrarsenseConsoleCommands()
{
    // Register custom console commands
    ConsoleCommands.Add(MakeUnique<FAutoConsoleCommand>(
        TEXT("r.WorldRendering"),
        TEXT("Toggle World rendering"),
        FExecuteAction::CreateLambda([this]() { ToggleWorldRendering(); })
    ));
 
    ConsoleCommands.Add(MakeUnique<FAutoConsoleCommand>(
        TEXT("r.InstancedRendering"),
        TEXT("Toggle Agrarsense Instanced rendering"),
        FExecuteAction::CreateLambda([this]() { ToggleInstancedRendering(); })
    ));
 
#if WITH_EDITOR
    // With following commands,
    // you can hide/show all InstancedActors to improve Unreal Editor performance
    ConsoleCommands.Add(MakeUnique<FAutoConsoleCommand>(
        TEXT("r.HideInstancedActors"),
        TEXT("Hide all Agrarsense Instanced actors"),
        FExecuteAction::CreateLambda([this]() { SetInstancedActorsVisibilityEditor(false); })
    ));
 
    ConsoleCommands.Add(MakeUnique<FAutoConsoleCommand>(
        TEXT("r.ShowInstancedActors"),
        TEXT("Show all Agrarsense Instanced actors"),
        FExecuteAction::CreateLambda([this]() { SetInstancedActorsVisibilityEditor(true); })
    ));
 
    ConsoleCommands.Add(MakeUnique<FAutoConsoleCommand>(
        TEXT("r.HideTrees"),
        TEXT("Hide all Agrarsense Instanced Trees"),
        FExecuteAction::CreateLambda([this]() { SetInstacedTreesVisibilityEditor(false); })
    ));
 
    ConsoleCommands.Add(MakeUnique<FAutoConsoleCommand>(
        TEXT("r.ShowTrees"),
        TEXT("Show all Agrarsense Instanced Trees"),
        FExecuteAction::CreateLambda([this]() { SetInstacedTreesVisibilityEditor(true); })
    ));
#endif
}
 
UAgrarsenseConsoleCommands::~UAgrarsenseConsoleCommands()
{
    // Unregister all added console commands
    for (TUniquePtr<FAutoConsoleCommand>& Command : ConsoleCommands)
    {
        Command.Reset();
    }
}
 
void UAgrarsenseConsoleCommands::ToggleWorldRendering()
{
    if (GEngine && GEngine->GameViewport)
    {
        GEngine->GameViewport->bDisableWorldRendering = !GEngine->GameViewport->bDisableWorldRendering;
    }
}
 
void UAgrarsenseConsoleCommands::ToggleInstancedRendering()
{
    if (GEngine && GEngine->GameViewport)
    {
        UWorld* World = GEngine->GameViewport->GetWorld();
        if (World)
        {
            auto* InstanceRenderer = UAgrarsenseStatics::GetInstancedRenderer(World);
            if (InstanceRenderer)
            {
                InstanceRenderer->SetInstancedRendering(!InstanceRenderer->IsRendering());
            }
        }
    }
}
 
void UAgrarsenseConsoleCommands::SetInstancedActorsVisibilityEditor(bool Visible)
{
#if WITH_EDITOR
    UWorld* World = GEditor ? GEditor->GetEditorWorldContext().World() : nullptr;
    if (!World)
    {
        return;
    }
 
    for (TActorIterator<AInstancedActor> ActorItr(World); ActorItr; ++ActorItr)
    {
        AInstancedActor* InstancedActor = *ActorItr;
        if (InstancedActor)
        {
            UStaticMeshComponent* StaticMeshComponent = InstancedActor->GetStaticMeshComponent();
            if (StaticMeshComponent)
            {
                StaticMeshComponent->SetVisibility(Visible);
            }
        }
    }
#endif
}
 
void UAgrarsenseConsoleCommands::SetInstacedTreesVisibilityEditor(bool Visible)
{
#if WITH_EDITOR
    
    TArray<FString> TreeNames = { "birch", "spruce", "pine", "alder", "willow" };
 
    UWorld* World = GEditor ? GEditor->GetEditorWorldContext().World() : nullptr;
    if (!World)
    {
        return;
    }
 
    for (TActorIterator<AInstancedActor> ActorItr(World); ActorItr; ++ActorItr)
    {
        AInstancedActor* InstancedActor = *ActorItr;
        if (InstancedActor)
        {
            UStaticMeshComponent* StaticMeshComponent = InstancedActor->GetStaticMeshComponent();
            if (StaticMeshComponent)
            {
                // This is not that fast but this is fine this usage..
                bool found = false;
                UStaticMesh* Mesh = StaticMeshComponent->GetStaticMesh();
                if (Mesh) 
                {
                    FString MeshName = Mesh->GetName().ToLower();
                    for (size_t i = 0; i < TreeNames.Num(); i++)
                    {
                        if (MeshName.Contains(TreeNames[i]))
                        {
                            found = true;
                            break;
                        }
                    }
                }
            
                if (found)
                {
                    StaticMeshComponent->SetVisibility(Visible);
                }
            }
        }
    }
#endif
}