da/d0b/_ts_binding_8h_source.htm

#pragma once


#include <TypeScriptPlugin/TypeScriptPluginDLL.h>


#include <Core/Console/ConsoleFunction.h>

#include <Core/ResourceManager/ResourceHandle.h>

#include <Core/Scripting/DuktapeContext.h>

#include <Core/World/Declarations.h>

#include <Core/World/World.h>

#include <Foundation/Configuration/CVar.h>

#include <Foundation/Containers/HashTable.h>

#include <Foundation/Math/Declarations.h>

#include <Foundation/Types/Uuid.h>

#include <TypeScriptPlugin/Resources/ScriptCompendiumResource.h>

#include <TypeScriptPlugin/Transpiler/Transpiler.h>


class plWorld;

class plTypeScriptComponent;

struct plMsgTypeScriptMsgProxy;


using plJavaScriptResourceHandle = plTypedResourceHandle<class plJavaScriptResource>;


enum plTypeScriptBindingIndexProperty

{

  ComponentHandle,

  GameObjectHandle

};


class PL_TYPESCRIPTPLUGIN_DLL plTypeScriptBinding

{

public:


  struct TsMessageHandler

  {

    const plRTTI* m_pMessageType = nullptr;

    plUInt32 m_uiMessageTypeNameHash = 0;

    plString m_sHandlerFunc;

  };


  struct TsComponentInfo

  {

    plString m_sComponentTypeName;

    plHybridArray<TsMessageHandler, 4> m_MessageHandlers;

  };


  using TsComponentTypeInfo = plMap<plUuid, TsComponentInfo>::ConstIterator;


public:

  plTypeScriptBinding();

  ~plTypeScriptBinding();


  plResult Initialize(plWorld& ref_world);

  plResult LoadComponent(const plUuid& typeGuid, TsComponentTypeInfo& out_typeInfo);


  plResult FindScriptComponentInfo(const char* szComponentType, TsComponentTypeInfo& out_typeInfo);


  void RegisterMessageHandlersForComponentType(const char* szComponent, const plUuid& componentType);


  PL_ALWAYS_INLINE plDuktapeContext& GetDukTapeContext() { return m_Duk; }

  PL_ALWAYS_INLINE duk_context* GetDukContext() { return m_Duk.GetContext(); }


  void Update();


private:

  static void GetTsName(const plRTTI* pRtti, plStringBuilder& out_sName);


  plDuktapeContext m_Duk;

  bool m_bInitialized = false;

  plMap<plUuid, bool> m_LoadedComponents;

  plScriptCompendiumResourceHandle m_hScriptCompendium;


public:

  static plResult SetupProjectCode();


private:

  static void GenerateComponentCode(plStringBuilder& out_Code, const plRTTI* pRtti);

  static void GenerateExposedFunctionsCode(plStringBuilder& out_Code, const plRTTI* pRtti);

  static void GeneratePropertiesCode(plStringBuilder& out_Code, const plRTTI* pRtti);

  static void GenerateAllComponentsCode(plStringBuilder& out_Code);

  static void GenerateComponentsFile(const char* szFile);

  static void InjectComponentImportExport(plStringBuilder& content, const char* szComponentFile);

  static void InjectMessageImportExport(plStringBuilder& content, const char* szComponentFile);

  static void GenerateEnumsFile(const char* szFile, const plSet<const plRTTI*>& items);

  static void InjectEnumImportExport(plStringBuilder& content, const char* szEnumFile);

  static void InjectFlagsImportExport(plStringBuilder& content, const char* szEnumFile);

  static void GenerateConstructorString(plStringBuilder& out_String, const plVariant& value);


  static void RemoveAutoGeneratedCode(plStringBuilder& content);

  static void AppendToTextFile(plStringBuilder& content, plStringView text);


  static plSet<const plRTTI*> s_RequiredEnums;

  static plSet<const plRTTI*> s_RequiredFlags;


public:


  struct FunctionBinding

  {

    const plAbstractFunctionProperty* m_pFunc = nullptr;

  };


  static const FunctionBinding* FindFunctionBinding(plUInt32 uiFunctionHash);


private:

  static plUInt32 ComputeFunctionBindingHash(const plRTTI* pType, const plAbstractFunctionProperty* pFunc);

  static void SetupRttiFunctionBindings();

  static const char* TsType(const plRTTI* pRtti);

  static int __CPP_Binding_RegisterMessageHandler(duk_context* pDuk);


  static plHashTable<plUInt32, FunctionBinding> s_BoundFunctions;


public:


  struct PropertyBinding

  {

    const plAbstractMemberProperty* m_pMember = nullptr;

  };


  static const PropertyBinding* FindPropertyBinding(plUInt32 uiHash);


  static void SyncPlObjectToTsObject(duk_context* pDuk, const plRTTI* pRtti, const void* pObject, plInt32 iObjIdx);

  static void SyncTsObjectPlTsObject(duk_context* pDuk, const plRTTI* pRtti, void* pObject, plInt32 iObjIdx);


private:

  static plUInt32 ComputePropertyBindingHash(const plRTTI* pType, const plAbstractMemberProperty* pMember);

  static void SetupRttiPropertyBindings();


  static plHashTable<plUInt32, PropertyBinding> s_BoundProperties;


public:

  plUniquePtr<plMessage> MessageFromParameter(duk_context* pDuk, plInt32 iObjIdx, plTime delay);

  static void DukPutMessage(duk_context* pDuk, const plMessage& msg);


  bool HasMessageHandler(const TsComponentTypeInfo& typeInfo, const plRTTI* pMsgRtti) const;

  bool DeliverMessage(const TsComponentTypeInfo& typeInfo, plTypeScriptComponent* pComponent, plMessage& ref_msg, bool bSynchronizeAfterwards);

  bool DeliverTsMessage(const TsComponentTypeInfo& typeInfo, plTypeScriptComponent* pComponent, const plMsgTypeScriptMsgProxy& msg);


private:

  static void GenerateMessagesFile(const char* szFile);

  static void GenerateAllMessagesCode(plStringBuilder& out_Code);

  static void GenerateMessageCode(plStringBuilder& out_Code, const plRTTI* pRtti);

  static void GenerateMessagePropertiesCode(plStringBuilder& out_Code, const plRTTI* pRtti);


  plInt32 m_iMsgDeliveryRecursion = 0;

  plUuid m_CurrentTsMsgHandlerRegistrator;

  plMap<plUuid, TsComponentInfo> m_TsComponentTypes;


private:

  static int DukSearchModule(duk_context* pDuk);


private:

  plResult Init_RequireModules();

  plResult Init_Log();

  plResult Init_Utils();

  plResult Init_Time();

  plResult Init_GameObject();

  plResult Init_Component();

  plResult Init_World();

  plResult Init_Clock();

  plResult Init_Random();

  plResult Init_FunctionBinding();

  plResult Init_PropertyBinding();

  plResult Init_Debug();

  plResult Init_Physics();


public:

  static plWorld* RetrieveWorld(duk_context* pDuk);

  static plTypeScriptBinding* RetrieveBinding(duk_context* pDuk);


  plWorld* GetWorld() { return m_pWorld; }


private:

  void StoreWorld(plWorld* pWorld);


  plWorld* m_pWorld = nullptr;

  static plHashTable<duk_context*, plWorld*> s_DukToWorld;


public:

  static plGameObjectHandle RetrieveGameObjectHandle(duk_context* pDuk, plInt32 iObjIdx = 0 /* use 0, if the game object is passed in as the 'this' object (first parameter) */);

  static plGameObject* ExpectGameObject(duk_context* pDuk, plInt32 iObjIdx = 0 /* use 0, if the game object is passed in as the 'this' object (first parameter) */);

  bool DukPutGameObject(const plGameObjectHandle& hObject);

  void DukPutGameObject(const plGameObject* pObject);


public:

  void DukPutComponentObject(plComponent* pComponent);

  static plComponentHandle RetrieveComponentHandle(duk_context* pDuk, plInt32 iObjIdx = 0 /* use 0, if the component is passed in as the 'this' object (first parameter) */);


  template <typename ComponentType>

  static ComponentType* ExpectComponent(duk_context* pDuk, plInt32 iObjIdx = 0 /* use 0, if the game object is passed in as the 'this' object (first parameter) */);


  static void PushVec2(duk_context* pDuk, const plVec2& value);

  static void SetVec2(duk_context* pDuk, plInt32 iObjIdx, const plVec2& value);

  static void SetVec2Property(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plVec2& value);

  static plVec2 GetVec2(duk_context* pDuk, plInt32 iObjIdx, const plVec2& vFallback = plVec2::MakeZero());

  static plVec2 GetVec2Property(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plVec2& vFallback = plVec2::MakeZero());


  static void PushVec3(duk_context* pDuk, const plVec3& value);

  static void SetVec3(duk_context* pDuk, plInt32 iObjIdx, const plVec3& value);

  static void SetVec3Property(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plVec3& value);

  static plVec3 GetVec3(duk_context* pDuk, plInt32 iObjIdx, const plVec3& vFallback = plVec3::MakeZero());

  static plVec3 GetVec3Property(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plVec3& vFallback = plVec3::MakeZero());


  static void PushMat3(duk_context* pDuk, const plMat3& value);

  static void SetMat3(duk_context* pDuk, plInt32 iObjIdx, const plMat3& value);

  static void SetMat3Property(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plMat3& value);

  static plMat3 GetMat3(duk_context* pDuk, plInt32 iObjIdx, const plMat3& mFallback = plMat3::MakeIdentity());

  static plMat3 GetMat3Property(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plMat3& mFallback = plMat3::MakeIdentity());


  static void PushMat4(duk_context* pDuk, const plMat4& value);

  static void SetMat4(duk_context* pDuk, plInt32 iObjIdx, const plMat4& value);

  static void SetMat4Property(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plMat4& value);

  static plMat4 GetMat4(duk_context* pDuk, plInt32 iObjIdx, const plMat4& mFallback = plMat4::MakeIdentity());

  static plMat4 GetMat4Property(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plMat4& mFallback = plMat4::MakeIdentity());


  static void PushQuat(duk_context* pDuk, const plQuat& value);

  static void SetQuat(duk_context* pDuk, plInt32 iObjIdx, const plQuat& value);

  static void SetQuatProperty(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plQuat& value);

  static plQuat GetQuat(duk_context* pDuk, plInt32 iObjIdx, plQuat qFallback = plQuat::MakeIdentity());

  static plQuat GetQuatProperty(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, plQuat qFallback = plQuat::MakeIdentity());


  static void PushColor(duk_context* pDuk, const plColor& value);

  static void SetColor(duk_context* pDuk, plInt32 iObjIdx, const plColor& value);

  static void SetColorProperty(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plColor& value);

  static plColor GetColor(duk_context* pDuk, plInt32 iObjIdx, const plColor& fallback = plColor::White);

  static plColor GetColorProperty(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plColor& fallback = plColor::White);


  static void PushTransform(duk_context* pDuk, const plTransform& value);

  static void SetTransform(duk_context* pDuk, plInt32 iObjIdx, const plTransform& value);

  static void SetTransformProperty(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plTransform& value);

  static plTransform GetTransform(duk_context* pDuk, plInt32 iObjIdx, const plTransform& fallback = plTransform::MakeIdentity());

  static plTransform GetTransformProperty(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plTransform& fallback = plTransform::MakeIdentity());


  static void PushVariant(duk_context* pDuk, const plVariant& value);

  static void SetVariantProperty(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plVariant& value);

  static plVariant GetVariant(duk_context* pDuk, plInt32 iObjIdx, const plRTTI* pType);

  static plVariant GetVariantProperty(duk_context* pDuk, const char* szPropertyName, plInt32 iObjIdx, const plRTTI* pType);


public:

  plMap<plString, plUniquePtr<plCVar>> m_CVars;


  struct ConsoleFuncBinding2

  {

    plComponentHandle m_hOwner;

    plUInt32 m_uiFuncStashIdx = 0;

  };


  struct ConsoleFuncBinding

  {

    plUniquePtr<plConsoleFunctionBase> m_pFunc;

    plHybridArray<ConsoleFuncBinding2, 4> m_Registered;

  };


  plMap<plString, ConsoleFuncBinding> m_ConsoleFuncs;


  void StoreConsoleFuncCall(plConsoleFunctionBase* pFunc, const plArrayPtr<plVariant>& params);


private:

  void ExecuteConsoleFuncs();


  struct ConsoleFuncCall

  {

    plConsoleFunctionBase* m_pFunc;

    plHybridArray<plVariant, 4> m_Arguments;

  };


  plHybridArray<ConsoleFuncCall, 4> m_CFuncCalls;


public:

  bool RegisterGameObject(plGameObjectHandle hHandle, plUInt32& out_uiStashIdx);

  plResult RegisterComponent(plStringView sTypeName, plComponentHandle hHandle, plUInt32& out_uiStashIdx, bool bIsNativeComponent);


  void CleanupStash(plUInt32 uiNumIterations);


  plUInt32 AcquireStashObjIndex();

  void ReleaseStashObjIndex(plUInt32 uiIdx);


private:

  static void StoreReferenceInStash(duk_context* pDuk, plUInt32 uiStashIdx);

  static bool DukPushStashObject(duk_context* pDuk, plUInt32 uiStashIdx);


  static constexpr plUInt32 c_uiMaxMsgStash = 512;

  static constexpr plUInt32 c_uiFirstStashMsgIdx = 512;

  static constexpr plUInt32 c_uiLastStashMsgIdx = c_uiFirstStashMsgIdx + c_uiFirstStashMsgIdx;

  static constexpr plUInt32 c_uiFirstStashObjIdx = c_uiLastStashMsgIdx;

  plUInt32 m_uiNextStashMsgIdx = c_uiFirstStashMsgIdx;

  plUInt32 m_uiNextStashObjIdx = c_uiFirstStashObjIdx;

  plMap<plGameObjectHandle, plUInt32> m_GameObjectToStashIdx;

  plMap<plComponentHandle, plUInt32> m_ComponentToStashIdx;

  plDeque<plUInt32> m_FreeStashObjIdx;

  plMap<plGameObjectHandle, plUInt32>::Iterator m_LastCleanupObj;

  plMap<plComponentHandle, plUInt32>::Iterator m_LastCleanupComp;

  plDynamicArray<plTime> m_StashedMsgDelivery;


};


template <typename ComponentType>

ComponentType* plTypeScriptBinding::ExpectComponent(duk_context* pDuk, plInt32 iObjIdx /*= 0 */)

{

  plComponentHandle hOwnHandle = plTypeScriptBinding::RetrieveComponentHandle(pDuk, iObjIdx);


  ComponentType* pComponent = nullptr;

  plWorld* pWorld = plTypeScriptBinding::RetrieveWorld(pDuk);

  PL_VERIFY(pWorld->TryGetComponent(hOwnHandle, pComponent), "Invalid component parameter");


  return pComponent;

}

plAbstractFunctionProperty
The base class for a property that represents a function.
Definition AbstractProperty.h:535

plAbstractMemberProperty
This is the base class for all properties that are members of a class. It provides more information a...
Definition AbstractProperty.h:237

plArrayPtr
This class encapsulates an array and it's size. It is recommended to use this class instead of plain ...
Definition ArrayPtr.h:37

plColor
plColor represents an RGBA color in linear color space. Values are stored as float,...
Definition Color.h:44

plColor::White
static const plColor White
#FFFFFF
Definition Color.h:194

plComponent
Base class of all component types.
Definition Component.h:25

plConsoleFunctionBase
Base class for all types of plConsoleFunction, represents functions to be exposed to plConsole.
Definition ConsoleFunction.h:37

plDeque
Definition Deque.h:270

plDynamicArray
Definition DynamicArray.h:81

plGameObject
This class represents an object inside the world.
Definition GameObject.h:32

plHashTable
Definition HashTable.h:333

plHybridArray
A hybrid array uses in-place storage to handle the first few elements without any allocation....
Definition HybridArray.h:12

plMap
Definition Map.h:408

plMat3Template< float >

plMat3Template< float >::MakeIdentity
static plMat3Template< float > MakeIdentity()
Definition Mat3_inl.h:48

plMat4Template< float >

plMat4Template< float >::MakeIdentity
static plMat4Template< float > MakeIdentity()
Definition Mat4_inl.h:75

plMessage
Base class for all message types. Each message type has it's own id which is used to dispatch message...
Definition Message.h:22

plQuatTemplate< float >

plQuatTemplate< float >::MakeIdentity
static const plQuatTemplate< float > MakeIdentity()
Definition Quat_inl.h:29

plRTTI
This class holds information about reflected types. Each instance represents one type that is known t...
Definition RTTI.h:30

plSet
Definition Set.h:238

plStringBuilder
plStringBuilder is a class that is meant for creating and modifying strings.
Definition StringBuilder.h:35

plStringView
plStringView represent a read-only sub-string of a larger string, as it can store a dedicated string ...
Definition StringView.h:34

plTransformTemplate< float >

plTransformTemplate< float >::MakeIdentity
static plTransformTemplate< float > MakeIdentity()
Definition Transform_inl.h:25

plTypeScriptBinding
Definition TsBinding.h:30

plTypeScriptComponent
Definition TypeScriptComponent.h:47

plTypedResourceHandle
The plTypedResourceHandle controls access to an plResource.
Definition ResourceHandle.h:136

plUniquePtr
A Unique ptr manages an object and destroys that object when it goes out of scope....
Definition UniquePtr.h:10

plUuid
This data type is the abstraction for 128-bit Uuid (also known as GUID) instances.
Definition Uuid.h:11

plVariant
plVariant is a class that can store different types of variables, which is useful in situations where...
Definition Variant.h:44

plVec2Template< float >

plVec2Template< float >::MakeZero
static constexpr plVec2Template< float > MakeZero()
Definition Vec2.h:49

plVec3Template< float >

plVec3Template< float >::MakeZero
static plVec3Template< float > MakeZero()
Definition Vec3.h:38

plWorld
A world encapsulates a scene graph of game objects and various component managers and their component...
Definition World.h:22

plWorld::TryGetComponent
bool TryGetComponent(const plComponentHandle &hComponent, ComponentType *&out_pComponent)
Returns whether a component with the given handle exists and if so writes out the corresponding point...
Definition World_inl.h:264

plComponentHandle
A handle to a component.
Definition Declarations.h:138

plGameObjectHandle
A handle to a game object.
Definition Declarations.h:76

plHybridString< 32, plDefaultAllocatorWrapper >

plMapBaseConstIteratorBase
Base class for all iterators.
Definition Map.h:11

plMapBaseIteratorBase
Forward Iterator to iterate over all elements in sorted order.
Definition Map.h:103

plMsgTypeScriptMsgProxy
Definition TypeScriptComponent.h:17

plResult
Default enum for returning failure or success, instead of using a bool.
Definition Types.h:54

plTime
The time class encapsulates a double value storing the time in seconds.
Definition Time.h:12

plTypeScriptBinding::ConsoleFuncBinding2
Definition TsBinding.h:282

plTypeScriptBinding::ConsoleFuncBinding
Definition TsBinding.h:288

plTypeScriptBinding::FunctionBinding
Definition TsBinding.h:105

plTypeScriptBinding::PropertyBinding
Definition TsBinding.h:126

plTypeScriptBinding::TsComponentInfo
Definition TsBinding.h:40

plTypeScriptBinding::TsMessageHandler
Definition TsBinding.h:33