World.h

Go to the documentation of this file.

 
#pragma once
 
#include "krpch.h"
 
#include "Object.h"
#include "SubClassOf.h"
 
namespace Karma
{
    class AActor;
    class FTransform;
    struct FActorSpawnParameters;
    class APawn;
    class ULevel;
    class UClass;
    class UGameInstance;

    struct KARMA_API FActorSpawnParameters
    {
        FActorSpawnParameters();

        std::string m_Name;

        AActor* m_Template;

        AActor* m_Owner;

        APawn* m_Instigator;

        ULevel* m_OverrideLevel;
 
#if WITH_EDITOR
        class   UPackage* OverridePackage;

        FGuid   OverrideActorGuid;
#endif

        class   UChildActorComponent* m_OverrideParentComponent;

        // Need physics
        //ESpawnActorCollisionHandlingMethod SpawnCollisionHandlingOverride;
 
    private:
 
        //friend class UPackageMapClient;
 
        /* Is the actor remotely owned. This should only be set true by the package map when it is creating an actor on a client that was replicated from the server. */
        uint8_t m_bRemoteOwned : 1;
 
    public:

        enum class ESpawnActorNameMode : uint8_t
        {
            Required_Fatal,

            Required_ErrorAndReturnNull,

            Required_ReturnNull,

            Requested
        };

        ESpawnActorNameMode m_NameMode;

        EObjectFlags m_ObjectFlags;
 
        /* Custom function allowing the caller to specific a function to execute post actor construction but before other systems see this actor spawn. */
        // maybe later
        //TFunction<void(AActor*)> CustomPreSpawnInitalization;

        bool IsRemoteOwned() const { return m_bRemoteOwned; }

        uint8_t m_bNoFail : 1;

        uint8_t m_bDeferConstruction : 1;
    };

    class KARMA_API UWorld : public UObject
    {
        DECLARE_KARMA_CLASS(UWorld, UObject)
 
    public:
        UWorld();

        AActor* SpawnActor(UClass* Class, FTransform const* Transform, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters());

        template< class T >
        T* SpawnActor(UClass* Class, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters())
        {
            return CastChecked<T>(SpawnActor(Class, nullptr, SpawnParameters), ECastCheckedType::NullAllowed);
        }

        ULevel* GetPersistentLevel() const { return m_PersistentLevel; }

        inline void SetGameInstance(UGameInstance* NewGI)
        {
            m_OwningGameInstance = NewGI;
        }
 
    private:
//#if WITH_EDITORONLY_DATA
        ULevel*                               m_CurrentLevel;
//#endif

        ULevel*                               m_PersistentLevel;
 
 
        UGameInstance*                     m_OwningGameInstance;

        // Time variables
        double m_TimeSeconds;

        double m_UnpausedTimeSeconds;

        double m_RealTimeSeconds;

        double m_AudioTimeSeconds;

        float m_DeltaRealTimeSeconds;

        float m_DeltaTimeSeconds;

        double m_PauseDelay;

        bool m_bIsPaused;
 
    public:
        uint8_t m_bIsTearingDown : 1;

        //double m_TimeSeconds;

        uint8_t m_bActorsInitialized : 1;

        uint8_t m_bBegunPlay : 1;

        EWorldType::Type m_WorldType;

        //TEnumAsByte<ERHIFeatureLevel::Type> FeatureLevel;

        struct InitializationValues
        {
            InitializationValues()
                : bInitializeScenes(true)
                , bAllowAudioPlayback(true)
                , bRequiresHitProxies(true)
                , bCreatePhysicsScene(true)
                , bCreateNavigation(true)
                , bCreateAISystem(true)
                , bShouldSimulatePhysics(true)
                , bEnableTraceCollision(false)
                , bForceUseMovementComponentInNonGameWorld(false)
                , bTransactional(true)
                , bCreateFXSystem(true)
                , bCreateWorldPartition(false)
            {
            }

            uint32_t bInitializeScenes : 1;

            uint32_t bAllowAudioPlayback : 1;

            uint32_t bRequiresHitProxies : 1;

            uint32_t bCreatePhysicsScene : 1;

            uint32_t bCreateNavigation : 1;

            uint32_t bCreateAISystem : 1;

            uint32_t bShouldSimulatePhysics : 1;

            uint32_t bEnableTraceCollision : 1;

            uint32_t bForceUseMovementComponentInNonGameWorld : 1;

            uint32_t bTransactional : 1;

            uint32_t bCreateFXSystem : 1;

            uint32_t bCreateWorldPartition : 1;

            TSubclassOf<class AGameModeBase> DefaultGameMode;
 
            // Documentation left for extremely lazy and din kaat moments
            InitializationValues& InitializeScenes(const bool bInitialize) { bInitializeScenes = bInitialize; return *this; }
            InitializationValues& AllowAudioPlayback(const bool bAllow) { bAllowAudioPlayback = bAllow; return *this; }
            InitializationValues& RequiresHitProxies(const bool bRequires) { bRequiresHitProxies = bRequires; return *this; }
            InitializationValues& CreatePhysicsScene(const bool bCreate) { bCreatePhysicsScene = bCreate; return *this; }
            InitializationValues& CreateNavigation(const bool bCreate) { bCreateNavigation = bCreate; return *this; }
            InitializationValues& CreateAISystem(const bool bCreate) { bCreateAISystem = bCreate; return *this; }
            InitializationValues& ShouldSimulatePhysics(const bool bInShouldSimulatePhysics) { bShouldSimulatePhysics = bInShouldSimulatePhysics; return *this; }
            InitializationValues& EnableTraceCollision(const bool bInEnableTraceCollision) { bEnableTraceCollision = bInEnableTraceCollision; return *this; }
            InitializationValues& ForceUseMovementComponentInNonGameWorld(const bool bInForceUseMovementComponentInNonGameWorld) { bForceUseMovementComponentInNonGameWorld = bInForceUseMovementComponentInNonGameWorld; return *this; }
            InitializationValues& SetTransactional(const bool bInTransactional) { bTransactional = bInTransactional; return *this; }
            InitializationValues& CreateFXSystem(const bool bCreate) { bCreateFXSystem = bCreate; return *this; }
            InitializationValues& CreateWorldPartition(const bool bCreate) { bCreateWorldPartition = bCreate; return *this; }
            InitializationValues& SetDefaultGameMode(TSubclassOf<class AGameModeBase> GameMode) { DefaultGameMode = GameMode; return *this; }
        };

        void Tick(/*ELevelTick TickType,*/ float DeltaSeconds);
 
    public:
        // UWorld inlines:

        FORCEINLINE double GetTimeSeconds() const
        {
            return m_TimeSeconds;
        }

        FORCEINLINE ULevel* GetCurrentLevel() const
        {
            return m_CurrentLevel;
        }
 
    public:
        bool AreActorsInitialized() const;

        //void InitializeNewWorld(const InitializationValues IVS = InitializationValues(), bool bInSkipInitWorld = false);

        bool HasBegunPlay() const;

        static UWorld* CreateWorld(const EWorldType::Type InWorldType, bool bInformEngineOfWorld, const std::string& WorldName = "NoName", UPackage* InWorldPackage = NULL, bool bAddToRoot = true,/* ERHIFeatureLevel::Type InFeatureLevel = ERHIFeatureLevel::Num, const InitializationValues* InIVS = nullptr,*/ bool bInSkipInitWorld = false);

        void InitializeNewWorld(const InitializationValues IVS = InitializationValues(), bool bInSkipInitWorld = false);

        void InitializeActorsForPlay(const FURL& InURL, bool bResetTime = true/*, FRegisterComponentContext* Context = nullptr*/);

        void ModifyLevel(ULevel* Level) const;

        bool IsGameWorld() const;

        void RemoveActor(AActor* Actor, bool bShouldModifyLevel) const;

        bool ShivaActor(AActor* Actor, bool bNetForce = false, bool bShouldModifyLevel = true);

        void AddOnActorSpawnedHandler() const;
        void RemoveOnActorSpawnedHander() const {}

        /*mutable FOnActorSpawned*/ void OnActorSpawned();
    };
}