ScriptCoroutine.h

#pragma once
 
#include <Core/CoreDLL.h>
 
#include <Core/Scripting/ScriptRTTI.h>
 
class plScriptWorldModule;
 
using plScriptCoroutineId = plGenericId<20, 12>;
 
struct plScriptCoroutineHandle
{
  PL_DECLARE_HANDLE_TYPE(plScriptCoroutineHandle, plScriptCoroutineId);
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plScriptCoroutineHandle);
PL_DECLARE_CUSTOM_VARIANT_TYPE(plScriptCoroutineHandle);
 
class PL_CORE_DLL plScriptCoroutine
{
public:
  plScriptCoroutine();
  virtual ~plScriptCoroutine();
 
  plScriptCoroutineHandle GetHandle() { return plScriptCoroutineHandle(m_Id); }
 
  plStringView GetName() const { return m_sName; }
 
  plScriptInstance* GetScriptInstance() { return m_pInstance; }
  const plScriptInstance* GetScriptInstance() const { return m_pInstance; }
 
  plScriptWorldModule* GetScriptWorldModule() { return m_pOwnerModule; }
  const plScriptWorldModule* GetScriptWorldModule() const { return m_pOwnerModule; }
 
  struct Result
  {
    struct State
    {
      using StorageType = plUInt8;
 
      enum Enum
      {
        Invalid,
        Running,
        Completed,
        Failed,
 
        Default = Invalid,
      };
    };
 
    static PL_ALWAYS_INLINE Result Running(plTime maxDelay = plTime::MakeZero()) { return {State::Running, maxDelay}; }
    static PL_ALWAYS_INLINE Result Completed() { return {State::Completed}; }
    static PL_ALWAYS_INLINE Result Failed() { return {State::Failed}; }
 
    plEnum<State> m_State;
    plTime m_MaxDelay = plTime::MakeZero();
  };
 
  virtual void StartWithVarargs(plArrayPtr<plVariant> arguments) = 0;
  virtual void Stop() {}
  virtual Result Update(plTime deltaTimeSinceLastUpdate) = 0;
 
  void UpdateAndSchedule(plTime deltaTimeSinceLastUpdate = plTime::MakeZero());
 
private:
  friend class plScriptWorldModule;
  void Initialize(plScriptCoroutineId id, plStringView sName, plScriptInstance& inout_instance, plScriptWorldModule& inout_ownerModule);
  void Deinitialize();
 
  static const plAbstractFunctionProperty* GetUpdateFunctionProperty();
 
  plScriptCoroutineId m_Id;
  plHashedString m_sName;
  plScriptInstance* m_pInstance = nullptr;
  plScriptWorldModule* m_pOwnerModule = nullptr;
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plScriptCoroutine);
 
template <typename Derived, class... Args>
class plTypedScriptCoroutine : public plScriptCoroutine
{
private:
  template <std::size_t... I>
  PL_ALWAYS_INLINE void StartImpl(plArrayPtr<plVariant> arguments, std::index_sequence<I...>)
  {
    static_cast<Derived*>(this)->Start(plVariantAdapter<typename getArgument<I, Args...>::Type>(arguments[I])...);
  }
 
  virtual void StartWithVarargs(plArrayPtr<plVariant> arguments) override
  {
    StartImpl(arguments, std::make_index_sequence<sizeof...(Args)>{});
  }
};
 
struct plScriptCoroutineCreationMode
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    StopOther,     
    DontCreateNew, 
    AllowOverlap,  
 
    Default = StopOther
  };
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plScriptCoroutineCreationMode);
 
class PL_CORE_DLL plScriptCoroutineRTTI : public plRTTI, public plRefCountingImpl
{
public:
  plScriptCoroutineRTTI(plStringView sName, plUniquePtr<plRTTIAllocator>&& pAllocator);
  ~plScriptCoroutineRTTI();
 
private:
  plString m_sTypeNameStorage;
  plUniquePtr<plRTTIAllocator> m_pAllocatorStorage;
};
 
class PL_CORE_DLL plScriptCoroutineFunctionProperty : public plScriptFunctionProperty
{
public:
  plScriptCoroutineFunctionProperty(plStringView sName, const plSharedPtr<plScriptCoroutineRTTI>& pType, plScriptCoroutineCreationMode::Enum creationMode);
  ~plScriptCoroutineFunctionProperty();
 
  virtual plFunctionType::Enum GetFunctionType() const override { return plFunctionType::Member; }
  virtual const plRTTI* GetReturnType() const override { return nullptr; }
  virtual plBitflags<plPropertyFlags> GetReturnFlags() const override { return plPropertyFlags::Void; }
  virtual plUInt32 GetArgumentCount() const override { return 0; }
  virtual const plRTTI* GetArgumentType(plUInt32 uiParamIndex) const override { return nullptr; }
  virtual plBitflags<plPropertyFlags> GetArgumentFlags(plUInt32 uiParamIndex) const override { return plPropertyFlags::Void; }
 
  virtual void Execute(void* pInstance, plArrayPtr<plVariant> arguments, plVariant& out_returnValue) const override;
 
protected:
  plSharedPtr<plScriptCoroutineRTTI> m_pType;
  plEnum<plScriptCoroutineCreationMode> m_CreationMode;
};
 
class PL_CORE_DLL plScriptCoroutineMessageHandler : public plScriptMessageHandler
{
public:
  plScriptCoroutineMessageHandler(plStringView sName, const plScriptMessageDesc& desc, const plSharedPtr<plScriptCoroutineRTTI>& pType, plScriptCoroutineCreationMode::Enum creationMode);
  ~plScriptCoroutineMessageHandler();
 
  static void Dispatch(plAbstractMessageHandler* pSelf, void* pInstance, plMessage& ref_msg);
 
protected:
  plHashedString m_sName;
  plSharedPtr<plScriptCoroutineRTTI> m_pType;
  plEnum<plScriptCoroutineCreationMode> m_CreationMode;
};
 
template <>
struct plHashHelper<plScriptCoroutineHandle>
{
  PL_ALWAYS_INLINE static plUInt32 Hash(plScriptCoroutineHandle value) { return plHashHelper<plUInt32>::Hash(value.GetInternalID().m_Data); }
 
  PL_ALWAYS_INLINE static bool Equal(plScriptCoroutineHandle a, plScriptCoroutineHandle b) { return a == b; }
};
 
PL_ALWAYS_INLINE void operator<<(plStreamWriter& inout_stream, const plScriptCoroutineHandle& hValue) {}
PL_ALWAYS_INLINE void operator>>(plStreamReader& inout_stream, plScriptCoroutineHandle& ref_hValue) {}