Actor.h

#pragma once
 
#include "krpch.h"
#include "Object.h"
 
#include "GameFramework/SceneComponent.h"
 
namespace Karma
{
    class UActorComponent;
    class ULevel;
    class APawn;
    class FTransform;
    class UWorld;
    class UChildActorComponent;
 
    class KARMA_API AActor : public UObject
    {
        DECLARE_KARMA_CLASS(AActor, UObject)
 
    public:
        AActor();
 
    private:
        KarmaVector<std::shared_ptr<UActorComponent>> m_OwnedComponents;
 
        APawn* m_Instigator;
 
        uint8_t m_bHasFinishedSpawning : 1;
 
        uint8_t m_bActorInitialized : 1;
 
        static uint32_t m_BeginPlayCallDepth;
 
 
        // TWeakObjectPtr in UE
        std::shared_ptr<UChildActorComponent> m_ParentComponent;
 
        // TArray<TObjectPtr<UActorComponent>>
        KarmaVector<std::shared_ptr<UActorComponent>> m_InstanceComponents;
 
        enum class EActorBeginPlayState : uint8_t
        {
            HasNotBegunPlay,
            BeginningPlay,
            HasBegunPlay,
        };
 
        EActorBeginPlayState m_ActorHasBegunPlay : 2;
 
        uint8_t m_bActorBeginningPlayFromLevelStreaming : 1;
 
        uint8_t m_bActorWantsDestroyDuringBeginPlay : 1;
 
        uint8_t m_bAutoDestroyWhenFinished : 1;
 
    public:
        ULevel* GetLevel() const;
 
        void PostSpawnInitialize(FTransform const& SpawnTransform, AActor* InOwner, APawn* InInstigator, bool bRemoteOwned, bool bNoFail, bool bDeferConstruction);
 
        virtual UWorld* GetWorld() const override final;
 
        bool HasActorBegunPlay() const { return m_ActorHasBegunPlay == EActorBeginPlayState::HasBegunPlay; }
 
        bool IsActorBeginningPlay() const { return m_ActorHasBegunPlay == EActorBeginPlayState::BeginningPlay; }
 
        void DispatchBeginPlay(bool bFromLevelStreaming = false);
 
        virtual void SetOwner(AActor* NewOwner);
 
        void FinishSpawning(const FTransform& Transform, bool bIsDefaultTransform = false/*, const FComponentInstanceDataCache* InstanceDataCache = nullptr*/);
 
        inline bool IsOwnedBy(const AActor* TestOwner) const
        {
            for (const AActor* Arg = this; Arg; Arg = Arg->m_Owner)
            {
                if (Arg == TestOwner)
                {
                    return true;
                }
            }
            return false;
        }
 
        void PostActorConstruction();
 
        void GetComponents(KarmaVector<USceneComponent*>& OutComponents) const // make use of smartpointer ?
        {
            // We should consider removing this function.  It's not really hurting anything by existing but the one above it was added so that
            // we weren't assuming T*, preventing TObjectPtrs from working for this function.  The only downside is all the people who force the
            // template argument with GetComponents's code suddenly not compiling with no clear error message.
 
            OutComponents.SmartReset();
 
            // Our own implementation, different from UE, maybe sync in future
            typename std::vector<std::shared_ptr<UActorComponent>>::const_iterator iterator = m_OwnedComponents.GetElements().begin();
 
            USceneComponent* tempSceneComponent;
 
            while (iterator != m_OwnedComponents.GetElements().end())
            {
                tempSceneComponent = static_cast<USceneComponent*>((*iterator).get());
                if (tempSceneComponent != nullptr)
                {
                    OutComponents.Add(tempSceneComponent);
                }
            }
 
            /*
            ForEachComponent_Internal<T>(T::StaticClass(), bIncludeFromChildActors, [&](T* InComp)
                {
                    OutComponents.Add(InComp);
                });
                */
        }
 
        void GetComponents(KarmaVector<UActorComponent*>& OutComponents) const // make use of smartpointer ?
        {
            // We should consider removing this function.  It's not really hurting anything by existing but the one above it was added so that
            // we weren't assuming T*, preventing TObjectPtrs from working for this function.  The only downside is all the people who force the
            // template argument with GetComponents's code suddenly not compiling with no clear error message.
 
            OutComponents.SmartReset();
 
            // Our own implementation, different from UE, maybe sync in future
            typename std::vector<std::shared_ptr<UActorComponent>>::const_iterator iterator = m_OwnedComponents.GetElements().begin();
 
            USceneComponent* tempSceneComponent;
 
            while (iterator != m_OwnedComponents.GetElements().end())
            {
                tempSceneComponent = static_cast<USceneComponent*>((*iterator).get());
                if (tempSceneComponent != nullptr)
                {
                    OutComponents.Add(tempSceneComponent);
                }
            }
        }
 
        void SetInstigator(APawn* InInstigator);
 
        FORCEINLINE USceneComponent* GetRootComponent() const { return m_RootComponent; }
 
        bool SetRootComponent(USceneComponent* NewRootComponent);
 
        static void DispatchOnComponentsCreated(AActor* NewActor);
 
        const FTransform& GetTransform() const
        {
            return ActorToWorld();
        }
 
        inline const FTransform& ActorToWorld() const
        {
            return (m_RootComponent ? m_RootComponent->GetComponentTransform() : FTransform::m_Identity);
        }
 
        void InitializeComponents();
 
        virtual void PostInitializeComponents();
 
        AActor* GetParentActor() const;
 
        UChildActorComponent* GetParentComponent() const;
 
        void RemoveOwnedComponent(std::shared_ptr<UActorComponent> Component);
 
        bool GetAutoDestroyWhenFinished() const { return m_bAutoDestroyWhenFinished; }
 
        static USceneComponent* FixupNativeActorComponents(AActor* Actor);
 
        bool CanTick() const { return m_bCanEverTick; }
        void DisableTick(bool bDisable) { m_bCanEverTick = !bDisable; }
 
        virtual void Tick(float DeltaSeconds);
 
    public:
        float m_CreationTime;
 
        AActor* m_Owner;// UE uses smart pointer
 
        KarmaVector<AActor*> m_Children;
 
    protected:
        virtual void BeginPlay();
 
        //void ReceiveBeginPlay();
 
    protected:
        USceneComponent* m_RootComponent;
 
        bool m_bCanEverTick;
    };
}