struct EngineFunctionArgumentOffsets {};

template< typename T >
struct _EngineFunctionArgumentOffsets {
    static int* offsets()
    {
        static auto foo = new int[1] { 0 };
        return foo;
    }
};

template<typename ...ArgTs>
struct _EngineFunctionArgumentOffsets< void(ArgTs...) > : public EngineFunctionArgumentOffsets
{
private:
    template<typename T> using AVT = typename EngineTypeTraits<T>::ArgumentValueType;
    typedef fixed_tuple<AVT<ArgTs> ...> FixedArgs;

    template<size_t ...> struct Seq {};
    template<size_t N, size_t ...S> struct Gens : Gens<N - 1, N - 1, S...> {};
    template<size_t ...I> struct Gens<0, I...> { typedef Seq<I...> type; };

    using SeqType = typename Gens<sizeof...(ArgTs)>::type;

    template<size_t I>
    static int getOffset(const FixedArgs& args) {
        return (int)((size_t)& fixed_tuple_accessor<I>::get(args)) - ((size_t)& args);
    }

    template<size_t ...I>
    static int* offsetsDispatchHelper(const FixedArgs& args, Seq<I...>) {
        int *tmp = new int[sizeof...(ArgTs)] { getOffset<I>(args)... };
        return tmp;
    }

public:
    static int* offsets()
    {
        FixedArgs args;
        return offsetsDispatchHelper(args, SeqType());
    }
};