KarmaUtilities.h

Go to the documentation of this file.

#pragma once
 
#include "SubClassOf.h"
#include "Actor.h"
#include "stb_image.h"
#include "Level.h"
#include "World.h"
#include "WorldSettings.h"
 
namespace Karma
{
    class UObject;
    class AActor;
 
    class UClass;

    class KARMA_API KarmaUtilities
    {
    public:
        static std::string ReadFileToSpitString(const std::string& filePath);

        static std::string GetFilePath(const std::string& str);

        static unsigned char* GetImagePixelData(char const* fileName, int* width, int* height, int* channels, int req_comp);
    };

    class FActorIteratorState
    {
    public:
        const UWorld*                       m_CurrentWorld;

        KarmaVector<UObject*>               m_ObjectArray;

        int32_t                             m_Index;

        bool                                m_ReachedEnd;

        int32_t                             m_ConsideredCount;

        AActor*                             m_CurrentActor;

        KarmaVector<AActor*>                m_SpawnedActorArray;

        UClass*                             m_DesiredClass;

        //FDelegateHandle ActorSpawnedDelegateHandle;

        FActorIteratorState() {};

        FActorIteratorState(const UWorld* InWorld, const TSubclassOf<AActor> InClass) :
            m_CurrentWorld(InWorld),
            m_Index(-1),
            m_ReachedEnd(false),
            m_ConsideredCount(0),
            m_CurrentActor(nullptr),
            m_DesiredClass(InClass)
        {
            //check(IsInGameThread());
            KR_CORE_ASSERT(m_CurrentWorld, "");
 
    #if WITH_EDITOR
            // In the editor, you are more likely to have many worlds in memory at once.
            // As an optimization to avoid iterating over many actors that are not in the world we are asking for,
            // if the filter class is AActor, just use the actors that are in the world you asked for.
            // This could be useful in runtime code as well if there are many worlds in memory, but for now we will leave
            // it in editor code.
            if (InClass == AActor::StaticClass())
            {
                // First determine the number of actors in the world to reduce reallocations when we append them to the array below.
                int32 NumActors = 0;
                for (ULevel* Level : InWorld->GetLevels())
                {
                    if (Level)
                    {
                        NumActors += Level->Actors.Num();
                    }
                }
 
                // Presize the array
                ObjectArray.Reserve(NumActors);
 
 
                // Fill the array
                for (ULevel* Level : InWorld->GetLevels())
                {
                    if (Level)
                    {
                        ObjectArray.Append(Level->Actors);
                    }
                }
            }
            else
    #endif // WITH_EDITOR
            {
                constexpr EObjectFlags ExcludeFlags = RF_ClassDefaultObject;
                GetObjectsOfClass(InClass, m_ObjectArray, true, ExcludeFlags, EInternalObjectFlags::Garbage);
            }
 
 
            // const auto ActorSpawnedDelegate = FOnActorSpawned::FDelegate::CreateRaw(this, &FActorIteratorState::OnActorSpawned);
            // m_ActorSpawnedDelegateHandle = m_CurrentWorld->AddOnActorSpawnedHandler(ActorSpawnedDelegate);
        }

        ~FActorIteratorState()
        {
            //m_CurrentWorld->RemoveOnActorSpawnedHandler(ActorSpawnedDelegateHandle);
        }
 

        FORCEINLINE AActor* GetActorChecked() const
        {
            KR_CORE_ASSERT(m_CurrentActor, "");
            KR_CORE_ASSERT(!m_CurrentActor->IsUnreachable(), "");
 
            return m_CurrentActor;
        }
 
    private:
        /*
        void OnActorSpawned(AActor* InActor)
        {
            if (InActor->IsA(DesiredClass))
            {
                SpawnedActorArray.AddUnique(InActor);
            }
        }*/
    };

    enum EActorIteratorFlags
    {
        AllActors           = 0x00000000,
        SkipPendingKill     = 0x00000001,
        OnlySelectedActors  = 0x00000002,
        OnlyActiveLevels    = 0x00000004,
    };

    enum class EActorIteratorType
    {
        End
    };

    template <typename Derived>
    class TActorIteratorBase
    {
    private:
        EActorIteratorFlags m_Flags;
 
        // smart pointer?
        std::shared_ptr<FActorIteratorState> m_State;
 
    protected:
        TActorIteratorBase(EActorIteratorType)
            : m_Flags(EActorIteratorFlags::AllActors)
        {
        }

        TActorIteratorBase(const UWorld* InWorld, TSubclassOf<AActor> InClass, const EActorIteratorFlags InFlags)
            : m_Flags(InFlags)
        {
            m_State.reset(new FActorIteratorState(InWorld, InClass));
        }
 
    public:
        void operator++()
        {
            // Use local version to avoid LHSs as compiler is not required to write out member variables to memory.
            AActor* localCurrentActor = nullptr;
            int32_t             localIndex = m_State->m_Index;
            KarmaVector<UObject*>& localObjectArray = m_State->m_ObjectArray;// note that localObjectArray is a vector
            KarmaVector<AActor*>& localSpawnedActorArray = m_State->m_SpawnedActorArray; // Contains any actors spawned during iteration
            const UWorld* localCurrentWorld = m_State->m_CurrentWorld;
 
            int32_t lObjectArrayNum =               int32_t(localObjectArray.Num());
            int32_t lSAArrayNum =                   int32_t(localSpawnedActorArray.Num());
 
            while (++localIndex < (lObjectArrayNum + lSAArrayNum))
            {
                if (localIndex < lObjectArrayNum)
                {
                    localCurrentActor = static_cast<AActor*>(localObjectArray.GetElements()[localIndex]);
                }
                else
                {
                    localCurrentActor = localSpawnedActorArray.GetElements()[localIndex - lObjectArrayNum];
                }
                m_State->m_ConsideredCount++;// Number of actors that have been considered thus far
 
                ULevel* actorLevel = localCurrentActor ? localCurrentActor->GetLevel() : nullptr;
 
                if (actorLevel
                    && static_cast<const Derived*>(this)->IsActorSuitable(localCurrentActor)
                    && static_cast<const Derived*>(this)->CanIterateLevel(actorLevel) && actorLevel->GetWorld() == localCurrentWorld)
                {
                    // ignore non-persistent world settings
                    if (actorLevel == localCurrentWorld->GetPersistentLevel() || !localCurrentActor->IsA(AWorldSettings::StaticClass()))
                    {
                        m_State->m_CurrentActor = localCurrentActor;
                        m_State->m_Index = localIndex;
                        return;
                    }
                }
            }
            m_State->m_CurrentActor = nullptr;
            m_State->m_ReachedEnd = true;
        }

        FORCEINLINE AActor* operator*() const
        {
            return m_State->GetActorChecked();
        }

        FORCEINLINE AActor* operator->() const
        {
            return m_State->GetActorChecked();
        }

        FORCEINLINE explicit operator bool() const
        {
            return !m_State->m_ReachedEnd;
        }

        void ClearCurrent()
        {
            KR_CORE_ASSERT(!m_State->m_ReachedEnd, "");
            m_State->m_CurrentWorld->RemoveActor(m_State->m_CurrentActor, true);
        }

        int32 GetProgressNumerator() const
        {
            return m_State->m_ConsideredCount;
        }

        FORCEINLINE bool CanIterateLevel(const ULevel* Level) const
        {
            /*
            if (EnumHasAnyFlags(Flags, EActorIteratorFlags::OnlyActiveLevels))
            {
                const bool bIsLevelVisibleOrAssociating = (Level->bIsVisible && !Level->bIsBeingRemoved) || Level->bIsAssociatingLevel || Level->bIsDisassociatingLevel;
 
                // Only allow iteration of Level if it's in the currently active level collection of the world, or is a static level.
                const FLevelCollection* const ActorLevelCollection = Level->GetCachedLevelCollection();
                const FLevelCollection* const ActiveLevelCollection = Level->OwningWorld ? Level->OwningWorld->GetActiveLevelCollection() : nullptr;
 
                // If the world's active level collection is null, we can't apply any meaningful filter,
                // so just allow iteration in this case.
                const bool bIsCurrentLevelCollectionTicking = !ActiveLevelCollection || (ActorLevelCollection == ActiveLevelCollection);
 
                const bool bIsLevelCollectionNullOrStatic = !ActorLevelCollection || ActorLevelCollection->GetType() == ELevelCollectionType::StaticLevels;
                const bool bShouldIterateLevelCollection = bIsCurrentLevelCollectionTicking || bIsLevelCollectionNullOrStatic;
 
                return bIsLevelVisibleOrAssociating && bShouldIterateLevelCollection;
            }*/
 
            return true;
        }

        FORCEINLINE bool IsActorSuitable(const AActor* Actor) const
        {
            if (EnumHasAnyFlags(m_Flags, EActorIteratorFlags::SkipPendingKill) && !IsValid(Actor))
            {
                return false;
            }
 
            if (EnumHasAnyFlags(m_Flags, EActorIteratorFlags::OnlySelectedActors) && !Actor->IsSelected())
            {
                return false;
            }
 
            return true;
        }
    };
}