Given:
```D
struct pos {float x, y;}
draw(myBitmap, pos(320, 240), centered);
draw(pos(320, 240), myBitmap);
draw("text", myFont, pos(320, 240));
```
I'm writing a general "draw" template function that through
compile-time, calls an associated DAllegro/Allegro 5 function:
```
draw(myBitmap, pos(320, 240), centered); //
al_draw_bitmap(myBitmap, pos.x - myBitmap.w/2, pos.y -
myBitmap.h, 0);
draw(pos(320, 240), myBitmap); // order doesn't matter
draw("text", myFont, pos(320, 240)); // different function
al_draw_text(...)
```
So there's multiple sub-problems to solve. I asked this years
ago, and got 90% of the way done and then lost the code and
cannot find the original forum post.
The pos(320,240) part works fine already. I need:
- At compile-time, for a variadic template that can take any
number of arguments, if specific arguments are available, I
branch and use them to call a specific applicable C function.
I remember I need to write some sort of enum function that checks
"IsAny" if an argument is passed at all, as well as one to find
where that argument is. Passing duplicates probably don't matter
(at least not right now), first valid argument is fine. I can't
seem to write code (or find example code online) that does this.
But it's something like
```D
enum isAny() = .......;
void draw(T...)(T)
{
if(isAny(bitmap))
{
// it's a sprite, now find out if we need it rotated,
stretched, etc.
}
is(isAny(string))
{
// its text [...]
}
}
```
A separate problem I've run into is, the 'centered' construct. If
I have rotate(25) (rotate 25 degrees), that works. But I cannot
just pass a type named "centered" with no variable attached to
it, nor can I--I think--pass an enum. I could do centered(false)
or centered(0), but that's clunkier than just saying "if
'centered' is an argument, we center it. If not, we don't." I
could have a variable named centered, I guess. or an enum with
{isCentered=1, notCentered=0} and detect if the enum is passed.
Lot's of ways to skin this cat.
The idea here, is I've got a lot of optional arguments (centered,
tinted, rotated, scaled, sheared, etc) that I can pick from and I
don't want to have to sort through a list of 80 different
permutations of function signatures, or, one gigantic
megafunction with a ton of zeros/nulls for all the unused
arguments.
This is a bit of a confusing problem to explain, so I've probably
left something necessary out.
