From 6a9c09f1454102ad90cfcd053092239a94d4576b Mon Sep 17 00:00:00 2001 From: Lukas Joergensen Date: Sat, 3 Aug 2019 13:41:02 +0200 Subject: [PATCH] Update EngineAPI, use fixed_tuple as main underlying data structure This also fixes a few issues related to type conversions before data is sent to the engine function. Squash --- .../source/cinterface/c_consoleInterface.cpp | 14 ++- Engine/source/console/engineAPI.h | 114 +++++++++--------- Engine/source/console/engineFunctions.h | 22 ++-- 3 files changed, 79 insertions(+), 71 deletions(-) diff --git a/Engine/source/cinterface/c_consoleInterface.cpp b/Engine/source/cinterface/c_consoleInterface.cpp index 09b406da3..999956e18 100644 --- a/Engine/source/cinterface/c_consoleInterface.cpp +++ b/Engine/source/cinterface/c_consoleInterface.cpp @@ -26,6 +26,7 @@ namespace Con { + /* Consumer Callback is not defined as EngineType yet, until then we have to define these methods directly. DefineNewEngineFunction(AddConsumer, void, (ConsumerCallback cb), , "") { addConsumer(cb); @@ -35,6 +36,17 @@ namespace Con { removeConsumer(cb); } + */ + + TORQUE_API void fnAddConsumer(ConsumerCallback cb) + { + addConsumer(cb); + } + + TORQUE_API void fnRemoveConsumer(ConsumerCallback cb) + { + removeConsumer(cb); + } DefineNewEngineFunction(GetConsoleString, String, (String name),, "") { @@ -75,4 +87,4 @@ namespace Con { setBoolVariable(StringTable->insert(name), value); } -} \ No newline at end of file +} diff --git a/Engine/source/console/engineAPI.h b/Engine/source/console/engineAPI.h index 38a3238a6..5e371106f 100644 --- a/Engine/source/console/engineAPI.h +++ b/Engine/source/console/engineAPI.h @@ -335,10 +335,9 @@ template struct _EngineTrampoline { template< typename R, typename ...ArgTs > struct _EngineTrampoline< R( ArgTs ... ) > { - typedef std::tuple Args; - std::tuple argT; - typedef fixed_tuple FixedArgs; - fixed_tuple fixedArgT; + template using AVT = typename EngineTypeTraits::ArgumentValueType; + typedef fixed_tuple ...> Args; + Args argT; }; template< typename T > @@ -356,21 +355,21 @@ struct _EngineFunctionTrampoline< R(ArgTs...) > : public _EngineFunctionTrampoli { private: using Super = _EngineFunctionTrampolineBase< R(ArgTs...) >; - using ArgsType = typename Super::Args; - using FixedArgsType = typename Super::FixedArgs; + using SelfType = _EngineFunctionTrampoline< R(ArgTs...) >; + using ArgsType = typename _EngineFunctionTrampolineBase< R(ArgTs ...) >::Args; template struct Seq {}; template struct Gens : Gens {}; template struct Gens<0, I...>{ typedef Seq type; }; - + + template + static typename fixed_tuple_element>::type getAndToType(const ArgsType& args) { + return typename EngineTypeTraits>::type>::ArgumentToValue(fixed_tuple_accessor::get(args)); + } + template static R dispatchHelper(typename Super::FunctionType fn, const ArgsType& args, Seq) { - return R( fn(std::get(args) ...) ); - } - - template - static R dispatchHelper(typename Super::FunctionType fn, const FixedArgsType& args, Seq) { - return R( fn(fixed_tuple_accessor::get(args) ...) ); + return R( fn(SelfType::template getAndToType(args) ...) ); } using SeqType = typename Gens::type; @@ -379,11 +378,6 @@ public: { return dispatchHelper(fn, args, SeqType()); } - - static R jmp(typename Super::FunctionType fn, const FixedArgsType& args ) - { - return dispatchHelper(fn, args, SeqType()); - } }; // Trampolines for engine methods @@ -400,21 +394,21 @@ struct _EngineMethodTrampoline< Frame, R(ArgTs ...) > : public _EngineMethodTram using FunctionType = R( typename Frame::ObjectType*, ArgTs ...); private: using Super = _EngineMethodTrampolineBase< R(ArgTs ...) >; - using ArgsType = typename _EngineFunctionTrampolineBase< R(ArgTs ...) >::Args; - using FixedArgsType = typename Super::FixedArgs; + using SelfType = _EngineMethodTrampoline< Frame, R(ArgTs ...) >; + using ArgsType = typename _EngineMethodTrampolineBase< R(ArgTs ...) >::Args; template struct Seq {}; template struct Gens : Gens {}; template struct Gens<0, I...>{ typedef Seq type; }; - - template - static R dispatchHelper(Frame f, const ArgsType& args, Seq) { - return R( f._exec(std::get(args) ...) ); + + template + static typename fixed_tuple_element>::type getAndToType(const ArgsType& args) { + return typename EngineTypeTraits>::type>::ArgumentToValue(fixed_tuple_accessor::get(args)); } - + template - static R dispatchHelper(Frame f, const FixedArgsType& args, Seq) { - return R( f._exec(fixed_tuple_accessor::get(args) ...) ); + static R dispatchHelper(Frame f, const ArgsType& args, Seq) { + return R(f._exec(SelfType::template getAndToType(args) ...)); } using SeqType = typename Gens::type; @@ -426,14 +420,6 @@ public: f.object = object; return dispatchHelper(f, args, SeqType()); } - - static R jmp( typename Frame::ObjectType* object, const FixedArgsType& args ) - { - - Frame f; - f.object = object; - return dispatchHelper(f, args, SeqType()); - } }; /// @} @@ -568,7 +554,7 @@ namespace engineAPI{ { return EngineUnmarshallData< IthArgType >()( argv[ startArgc + index ] ); } else { - return std::get(defaultArgs.mArgs); + return fixed_tuple_accessor::get(defaultArgs.mArgs); } } @@ -700,7 +686,7 @@ public: #define DefineEngineFunction( name, returnType, args, defaultArgs, usage ) \ static inline returnType _fn ## name ## impl args; \ TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name \ - ( _EngineFunctionTrampoline< returnType args >::FixedArgs a ) \ + ( _EngineFunctionTrampoline< returnType args >::Args a ) \ { \ _CHECK_ENGINE_INITIALIZED( name, returnType ); \ return EngineTypeTraits< returnType >::ReturnValue( \ @@ -754,7 +740,7 @@ public: #define _DefineMethodTrampoline( className, name, returnType, args ) \ TORQUE_API EngineTypeTraits< returnType >::ReturnValueType \ - fn ## className ## _ ## name ( className* object, _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::FixedArgs a )\ + fn ## className ## _ ## name ( className* object, _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::Args a )\ { \ _CHECK_ENGINE_INITIALIZED( className::name, returnType ); \ return EngineTypeTraits< returnType >::ReturnValue( \ @@ -837,7 +823,7 @@ public: #define DefineEngineStaticMethod( className, name, returnType, args, defaultArgs, usage ) \ static inline returnType _fn ## className ## name ## impl args; \ TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name \ - ( _EngineFunctionTrampoline< returnType args >::FixedArgs a ) \ + ( _EngineFunctionTrampoline< returnType args >::Args a ) \ { \ _CHECK_ENGINE_INITIALIZED( className::name, returnType ); \ return EngineTypeTraits< returnType >::ReturnValue( \ @@ -872,25 +858,25 @@ public: ); \ static inline returnType _fn ## className ## name ## impl args -# define DefineEngineStringlyVariadicFunction(name,returnType,minArgs,maxArgs,usage) \ +# define DefineEngineStringlyVariadicFunction(name,returnType,minArgs,maxArgs,usage) \ static inline returnType _fn ## name ## impl (SimObject *, S32 argc, ConsoleValueRef *argv); \ TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name \ - (S32 argc, const char** argv) \ + (Vector* vec) \ { \ _CHECK_ENGINE_INITIALIZED( name, returnType ); \ - StringStackConsoleWrapper args(argc, argv); \ + StringStackConsoleWrapper args(vec->size(), vec->address()); \ return EngineTypeTraits< returnType >::ReturnValue( \ _fn ## name ## impl(NULL, args.count(), args) \ ); \ } \ - static _EngineFunctionDefaultArguments< void (S32 argc, const char** argv) > _fn ## name ## DefaultArgs; \ + static _EngineFunctionDefaultArguments< void (Vector* vec) > _fn ## name ## DefaultArgs; \ static EngineFunctionInfo _fn ## name ## FunctionInfo( \ #name, \ &_SCOPE<>()(), \ usage, \ - #returnType " " #name "(S32 argc, const char** argv)", \ + #returnType " " #name "(Vector args)", \ "fn" #name, \ - TYPE< returnType (S32 argc, const char** argv) >(), \ + TYPE< returnType (Vector* vec) >(), \ &_fn ## name ## DefaultArgs, \ ( void* ) &fn ## name, \ 0 \ @@ -899,34 +885,44 @@ public: returnType _fn ## name ## impl(SimObject *, S32 argc, ConsoleValueRef *argv) # define DefineEngineStringlyVariadicMethod(className, name,returnType,minArgs,maxArgs,usage) \ - static inline returnType _fn ## className ## _ ## name ## impl (className* object, S32 argc, ConsoleValueRef* argv); \ + struct _ ## className ## name ## frame \ + { \ + typedef className ObjectType; \ + className* object; \ + inline returnType _exec (S32 argc, ConsoleValueRef* argv) const; \ + }; \ TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name \ - (className* object, S32 argc, const char** argv) \ + (className* object, Vector* vec) \ { \ _CHECK_ENGINE_INITIALIZED( name, returnType ); \ - StringStackConsoleWrapper args(argc, argv); \ + StringStackConsoleWrapper args(vec->size(), vec->address()); \ + _ ## className ## name ## frame frame {}; \ + frame.object = static_cast< className* >( object ); \ return EngineTypeTraits< returnType >::ReturnValue( \ - _fn ## className ## _ ## name ## impl(object, args.count(), args) \ + frame._exec(args.count(), args) \ ); \ } \ - static _EngineFunctionDefaultArguments< void (className* object, S32 argc, const char** argv) > _fn ## className ## _ ## name ## DefaultArgs; \ - static EngineFunctionInfo _fn ## className ## _ ## name ## FunctionInfo( \ + static _EngineFunctionDefaultArguments< void (className* object, S32 argc, const char** argv) > \ + _fn ## className ## name ## DefaultArgs; \ + static EngineFunctionInfo _fn ## className ## name ## FunctionInfo( \ #name, \ - &_SCOPE<>()(), \ + &_SCOPE< className >()(), \ usage, \ - #returnType " " #name "(SimObject* object, S32 argc, const char** argv)", \ + "virtual " #returnType " " #name "(Vector args)", \ "fn" #className "_" #name, \ - TYPE< returnType (SimObject* object, S32 argc, const char** argv) >(), \ - &_fn ## className ## _ ## name ## DefaultArgs, \ + TYPE< _EngineMethodTrampoline< _ ## className ## name ## frame, returnType (Vector vec) >::FunctionType >(), \ + &_fn ## className ## name ## DefaultArgs, \ ( void* ) &fn ## className ## _ ## name, \ 0 \ ); \ returnType cm_##className##_##name##_caster(SimObject* object, S32 argc, ConsoleValueRef* argv) { \ AssertFatal( dynamic_cast( object ), "Object passed to " #name " is not a " #className "!" ); \ - conmethod_return_##returnType ) _fn ## className ## _ ## name ## impl(static_cast(object),argc,argv); \ + _ ## className ## name ## frame frame {}; \ + frame.object = static_cast< className* >( object ); \ + conmethod_return_##returnType ) frame._exec(argc,argv); \ }; \ ConsoleConstructor cc_##className##_##name##_obj(#className,#name,cm_##className##_##name##_caster,usage,minArgs,maxArgs); \ - static inline returnType _fn ## className ## _ ## name ## impl(className *object, S32 argc, ConsoleValueRef *argv) + inline returnType _ ## className ## name ## frame::_exec(S32 argc, ConsoleValueRef *argv) const @@ -937,7 +933,7 @@ public: #define DefineNewEngineFunction( name, returnType, args, defaultArgs, usage ) \ static inline returnType _fn ## name ## impl args; \ TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name \ - ( _EngineFunctionTrampoline< returnType args >::FixedArgs a ) \ + ( _EngineFunctionTrampoline< returnType args >::Args a ) \ { \ _CHECK_ENGINE_INITIALIZED( name, returnType ); \ return EngineTypeTraits< returnType >::ReturnValue( \ @@ -984,7 +980,7 @@ public: #define DefineNewEngineStaticMethod( className, name, returnType, args, defaultArgs, usage ) \ static inline returnType _fn ## className ## name ## impl args; \ TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name \ - ( _EngineFunctionTrampoline< returnType args >::FixedArgs a ) \ + ( _EngineFunctionTrampoline< returnType args >::Args a ) \ { \ _CHECK_ENGINE_INITIALIZED( className::name, returnType ); \ return EngineTypeTraits< returnType >::ReturnValue( \ diff --git a/Engine/source/console/engineFunctions.h b/Engine/source/console/engineFunctions.h index 8f2d600fe..8c6127374 100644 --- a/Engine/source/console/engineFunctions.h +++ b/Engine/source/console/engineFunctions.h @@ -94,22 +94,21 @@ struct EngineFunctionDefaultArguments template< typename T > struct _EngineFunctionDefaultArguments {}; -template -struct _EngineFunctionDefaultArguments< void(ArgTs...) > : public EngineFunctionDefaultArguments +template +struct _EngineFunctionDefaultArguments< R(ArgTs...) > : public EngineFunctionDefaultArguments { template using DefVST = typename EngineTypeTraits::DefaultArgumentValueStoreType; - fixed_tuple ...> mFixedArgs; - std::tuple ...> mArgs; + using SelfType = _EngineFunctionDefaultArguments< R(ArgTs...) >; + fixed_tuple...> mArgs; + private: - using SelfType = _EngineFunctionDefaultArguments< void(ArgTs...) >; - template struct Seq {}; template struct Gens : Gens {}; template struct Gens<0, I...>{ typedef Seq type; }; template - static void copyHelper(std::tuple ...> &args, std::tuple ...> &defaultArgs, Seq) { + static void copyHelper(std::tuple ...> &args, std::tuple ...> &defaultArgs, Seq) { std::tie(std::get(args)...) = defaultArgs; } @@ -117,7 +116,7 @@ private: template struct DodgyVCHelper { - using type = typename std::enable_if::type; + using type = typename std::enable_if...>>::type; }; template using MaybeSelfEnabled = typename DodgyVCHelper::type; @@ -128,15 +127,16 @@ private: template static MaybeSelfEnabled tailInit(TailTs ...tail) { std::tuple...> argsT; std::tuple...> tailT = std::make_tuple(tail...); - SelfType::copyHelper(argsT, tailT, typename Gens::type()); + SelfType::template copyHelper(argsT, tailT, typename Gens::type()); return argsT; }; public: template _EngineFunctionDefaultArguments(TailTs ...tail) - : EngineFunctionDefaultArguments({sizeof...(TailTs)}), mArgs(SelfType::tailInit(tail...)) + : EngineFunctionDefaultArguments({sizeof...(TailTs)}) { - fixed_tuple_mutator...), void(DefVST...)>::copy(mArgs, mFixedArgs); + std::tuple...> tmpTup = SelfType::tailInit(tail...); + fixed_tuple_mutator...), void(DefVST...)>::copy(tmpTup, mArgs); } };