Actor.h

Go to the documentation of this file.

 
#pragma once
 
#include "Karma/Core.h"
#include "Karma/Log.h"
#include "Karma/Core/KarmaTypes.h"
#include "Object.h"
#include "Components/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;
 

        std::shared_ptr<UChildActorComponent> m_ParentComponent;

        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);
                }
 
                // shouldn't we have iterator++
            }
        }

        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();
        }
        
        bool SetActorTransform(const FTransform& NewTransform/*, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None*/);

        bool SetActorLocation(const glm::vec3& NewLocation);
        
        bool SetActorRotation(TRotator NewRotation);
        
        void SetActorScale3D(glm::vec3 NewScale3D);
        
        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;
    };
}