Defer/cancel execution of functions and analyze their arguments

Question

I'm trying to write external draw call optimization, and for that I need to collect hooked calls, store their arguments to analyze them later on. I've been able to make deferred calls, and somewhat readable arguments, stored in tuple, but I need to read arguments from base class and after thorough googling I can't find anything applicable. I'll work with array of IDelegateBase mostly, and it would be very inconvenient to convert them to Delegate<...> with full signature, when I mostly would read just one argument. Therefore, I need virtual templated method in IDelegateBase, which would return n-th argument. But virtual templated methods are impossible, so probably I'd have to have templated method in base class, which would call non-template (boost::any?) virtual method and cast it's result, I suppose. But, anyway, I can't get n-th element from tuple via runtime variable.

#include <functional>
#include <iostream>

class IDelegateBase
{
public:
    virtual void invoke() { }
};
template <typename T, typename... Args>
class Delegate : public IDelegateBase
{
private:
    void (*_f)(Args...);
    std::tuple<Args...> _args;
public:
    Delegate(T& f, Args &...args)
        : _f(f), _args(args...) { }
    void invoke() final
    {
        std::apply(_f, _args);
    }
};
void a() { std::cout << "a called;\n"; }
void b(int x) { std::cout << "b called with " << x << "\n"; }
void c(int x, float y) { std::cout << "c called with " << x << ", " << y << "\n"; }
int main()
{
    
    IDelegateBase* d = new Delegate(a);
    d->invoke();
    int i = 42;
    d = new Delegate(b, i);
    d->invoke();
    i = 21;
    float f = 0.999;
    d = new Delegate(c, i, f);
    d->invoke();
    // I need something like this:
    auto test = d->getArgument<float>(1);
};

Update: Final solution with kind of type checking: https://godbolt.org/z/xeEWTeosx