ScriptWorldModule.h

#pragma once
 
#include <Core/ResourceManager/ResourceHandle.h>
#include <Core/Scripting/ScriptCoroutine.h>
#include <Core/Utils/IntervalScheduler.h>
#include <Core/World/World.h>
#include <Foundation/CodeUtils/Expression/ExpressionVM.h>
 
using plScriptClassResourceHandle = plTypedResourceHandle<class plScriptClassResource>;
class plScriptInstance;
 
class PL_CORE_DLL plScriptWorldModule : public plWorldModule
{
  PL_DECLARE_WORLD_MODULE();
  PL_ADD_DYNAMIC_REFLECTION(plScriptWorldModule, plWorldModule);
  PL_DISALLOW_COPY_AND_ASSIGN(plScriptWorldModule);
 
public:
  plScriptWorldModule(plWorld* pWorld);
  ~plScriptWorldModule();
 
  virtual void Initialize() override;
  virtual void WorldClear() override;
 
  void AddUpdateFunctionToSchedule(const plAbstractFunctionProperty* pFunction, void* pInstance, plTime updateInterval, bool bOnlyWhenSimulating);
  void RemoveUpdateFunctionToSchedule(const plAbstractFunctionProperty* pFunction, void* pInstance);
 
 
  plScriptCoroutineHandle CreateCoroutine(const plRTTI* pCoroutineType, plStringView sName, plScriptInstance& inout_instance, plScriptCoroutineCreationMode::Enum creationMode, plScriptCoroutine*& out_pCoroutine);
 
  void StartCoroutine(plScriptCoroutineHandle hCoroutine, plArrayPtr<plVariant> arguments);
 
  void StopAndDeleteCoroutine(plScriptCoroutineHandle hCoroutine);
 
  void StopAndDeleteCoroutine(plStringView sName, plScriptInstance* pInstance);
 
  void StopAndDeleteAllCoroutines(plScriptInstance* pInstance);
 
  bool IsCoroutineFinished(plScriptCoroutineHandle hCoroutine) const;
 
 
  plExpressionVM& GetSharedExpressionVM() { return m_SharedExpressionVM; }
 
  struct FunctionContext
  {
    enum Flags : plUInt8
    {
      None,
      OnlyWhenSimulating
    };
 
    plPointerWithFlags<const plAbstractFunctionProperty, 1> m_pFunctionAndFlags;
    void* m_pInstance = nullptr;
 
    bool operator==(const FunctionContext& other) const
    {
      return m_pFunctionAndFlags == other.m_pFunctionAndFlags && m_pInstance == other.m_pInstance;
    }
  };
 
private:
  void CallUpdateFunctions(const plWorldModule::UpdateContext& context);
 
  plIntervalScheduler<FunctionContext> m_Scheduler;
 
  plIdTable<plScriptCoroutineId, plUniquePtr<plScriptCoroutine>> m_RunningScriptCoroutines;
  plHashTable<plScriptInstance*, plSmallArray<plScriptCoroutineHandle, 8>> m_InstanceToScriptCoroutines;
  plDynamicArray<plUniquePtr<plScriptCoroutine>> m_DeadScriptCoroutines;
 
  plExpressionVM m_SharedExpressionVM;
};
 
 
template <>
struct plHashHelper<plScriptWorldModule::FunctionContext>
{
  PL_ALWAYS_INLINE static plUInt32 Hash(const plScriptWorldModule::FunctionContext& value)
  {
    plUInt32 hash = plHashHelper<const void*>::Hash(value.m_pFunctionAndFlags);
    hash = plHashingUtils::CombineHashValues32(hash, plHashHelper<void*>::Hash(value.m_pInstance));
    return hash;
  }
 
  PL_ALWAYS_INLINE static bool Equal(const plScriptWorldModule::FunctionContext& a, const plScriptWorldModule::FunctionContext& b) { return a == b; }
};