I'm working on a class to identify an image inside a texture, something like this:

```c++
using level_t = ...
using layer_t = ...
using face_t = ...

template <bool>
struct levels {};

template <>
struct levels<true> {
    level_t level = level_t{0};
};

template <bool>
struct layers {};

template <>
struct layers<true> {
    layer_t layer = layer_t{0};
};

template <bool>
struct faces {};

template <>
struct faces<true> {
    face_t face = face_t{0};
};

template <bool HasLevels, bool HasLayers, bool HasFaces>
struct index : levels<HasLevels>, layers<HasLayers>, faces<HasFaces> {};

```

Where `level_t`, `layer_t` and `face_t` are a sort of "strong typedef" for an int (basically different types that look like an int but without the implicit conversions).

Now I can use my type like so:

```c++
using Index1 = index<true, true, false>;
void f(Index1);

Index1 v;
v.level = level_t{1};
v.layer = layer_t[1};
f(v);

```

But to make the life easier for my users I want to allow this code:

```c++
f({level_t{1}, layer_t{1}};

```

The aggregate initialization is out due the base classes, so I need to write a constructor on my own; what is the best/smartest way to write a constructor that supports all the argument combinations (but not the reorder)?