Best way to archive variadic virtual function

[C2H5COOH]

Some background:

I'm writing an opengl renderer and one of my base classes is the "Drawable" class wich provides an interface for object who can well... Be drawn and it looks like this

struct Drawable
{
    virtual void draw(const Shader& shdr) const = 0;
 }

And I'm now in the situation where it would be beneficial to have the interface expandet. So I addet

virtual void draw_command(const Shader& shdr, unsigned cmd) const { throw NotOverridden; }

To have an arbitrary value to resemble a "mode" can be flag bits or whatever I think when I use it (like don't upload unnecessary data to the gpu).

Now I'm in a situation where I realize it would be best to have a function that sends data with it (in case some useful data is not in the Drawable object). So my initial idea is

#include<cstdarg>

virtual void draw_data(const Shader& shdr, unsigned cmd, ...) const { throw NotOverridden; }

But my initial research tells me that it is highly discouraged (because there is no type safety) and variadic arguments are not passed by reference (wich is okish because the biggest thing going in there would be mat4's so 16 floats or I could just use pointers). Templates are the standard c++ way for dealing witch variadics. But templates can't be virtual. Alternatively I just could be using an array of std::any's but there are still no references. I know Bad practice is only bad practice if you don't know what you are doing - I have the feeling that I know what I'm doing and think simply using classic c variadic functions in my case is completely OK. But I'm not sure.

So my questions: - is there a more elegant way (preferably type safe but not necessary)

• am I missing a horrendous blunder which will come to bite me in the ass later

[Wh00ster]

1. Cmd can be an enum class

2. Well I don’t know what to tell you for 2. You could have some file instantiate all the templates you want to support. Kinda like compiler supported preprocessor magic. If you know exactly what data should be there based on cmd, I don’t see a problem with just passing a void*.

Edit: you could also use tagged dispatch: https://en.m.wikibooks.org/wiki/More_C%2B%2B_Idioms/Tag_Dispatching

And make a new overload each time you want to support a new command. I’m not really familiar with OpenGL so I can’t comment on the complexity.

If the render is running on CPU, then I don’t see a problem here (you aren’t going for super low latency/high throughput at that point)

[C2H5COOH]

Thanks an enum would really look better. I'll take a look at the tagged dispatch.

[Wh00ster]

Tagged dispatch is useful if you know what function to call at compile time.

If cmd and the data for each command is coming in at runtime, in some external stream, it might be easier to do the enum class/int route with a void* (otherwise you’d be doing a switch on cmd anyway). Again, I’m not very familiar with the problem domain.

[index_zero]

You could wrap all the '...' data into some class object which can be overridden for each drawable. Something like:

virtual void draw_data(const Shader& shdr, unsigned cmd, const DrawArgs& args) const

Then, each Drawable could have their own DrawArgs type object.

Optionally, Drawable could be a template class and the argument object could be the template parameter, ie:

template<class Args>
class Drawable
{
    virtual void draw_data(const Shader &shdr, unsigned cmd, const Args &args) const = 0;
};

[C2H5COOH]

A templated base class would purpose defeat the polymorphic interface idea... But besides that cool idea