c++ - 避免补间库中的模板组合爆炸

Question

我正在尝试用 C++ 实现补间库。这主要是出于教育目的，因为可能有其他图书馆比我做得更好(例如:https://github.com/mobius3/tweeny，但在模板方面我无法理解)。

主要目标是在编译时做尽可能多的事情。否则我可以用一些函数指针来简化事情。

这里有几个(许多)缓动函数:

struct easing
{
    struct linear {
        template<typename T>
        static T run(float t, T start, T end) {
            return static_cast<T>((end - start) * t + start);
        }
    };

    struct quadratic_in {
        template<typename T>
        static T run(float t, T start, T end) {
            return static_cast<T>((end - start) * t * t + start);
        }
    };

    struct quadratic_out {
        template<typename T>
        static T run(float t, T start, T end) {
            return static_cast<T>((-(end - start)) * t * (t - 2) + start);
        }
    };
};

下面是库代码的相关部分:

namespace detail {
template <typename TEase, typename T>
struct tween
{
    T _from;
    T _to;
    float _running_time;
    float _duration;
    T* _value;
};

template <typename TEase, typename T>
bool update(tween<TEase, T>& tween, float dt)
{
    float t = tween._running_time / tween._duration;
    if (t > 1.0f)
    {
        *tween._value = tween._to;

        return false;
    }

    *tween._value = TEase::run(t, tween._from, tween._to);
    tween._running_time += dt;

    return true;
}

std::tuple<
    std::vector<tween<easing::linear, float>>,
    std::vector<tween<easing::quadratic_in, float>>,
    std::vector<tween<easing::quadratic_out, float>>,
    std::vector<tween<easing::linear, my_vec2_type>>,
    std::vector<tween<easing::quadratic_in, my_vec2_type>>,
    std::vector<tween<easing::quadratic_out, my_vec2_type>>,
    std::vector<tween<easing::linear, my_vec3_type>>,
    std::vector<tween<easing::quadratic_in, my_vec3_type>>,
    std::vector<tween<easing::quadratic_out, my_vec3_type>>,
    // Getting silly...
> g_tweens;
}

void update(float dt)
{
    // Can use std::apply with C++17
    my_apply([dt](auto& tweens) {
        for (auto it = begin(tweens); it != end(tweens);)
        {
            if (update(*it, dt))
            {
                ++it;
            }
            else
            {
                it = tweens.erase(it);
            }
        }
    }, detail::g_tweens);
}

template <typename TEasing, typename T>
void create(T* value, T to, float duration)
{
    std::get<std::vector<detail::tween<TEasing, T>>>(detail::g_tweens).push_back({ *value, to, 0.0f, duration, value });
}

还有一个例子:

my_vec3_type color(1.0f, 0.0f, 0.0f);
tween::create<easing::linear>(&color, my_vec3_type(0.0f, 1.0f, 0.0f), 1.0f);

for (int i = 0; i < 100; ++i)
{
    tween::update(0.01f);

    std::cout << "color = (" << color.r << ", " << color.g << ", " << color.b << ")" << std::endl;
}

这实际上主要是我想要的。当然，我需要将所有缓动类型添加到元组中 - 而且有很多 - 但我认为考虑到它们不太可能发生太大变化，可能是合理的。

但最初我只需要花车。现在我希望能够简化其他类型，例如颜色和其他一些类型。所以可能有数百种组合。任何其他想要使用它的人都需要编辑 g_tween 签名以添加他们自己的类型。

在我看来，最大的问题是补间类型的第二个模板参数允许我使用任何标量类型。我只是希望它适用于任何定义了正确运算符的东西。喜欢:

template <typename TEase>
struct tween
{
    std::any _from;
    std::any _to;
    float _running_time;
    float _duration;
    std::any* _value;
};

也就是说，如果有某种方法可以恢复类型，那么我就可以调用正确的缓动函数。欢迎任何建议或替代方案!

Answer 1

简而言之，您想键入删除。

所以 here是作为伪方法指针实现的完整类型删除库。

您可以做一些奇特的事情，将调度与存储分开。或者您可以直接使用它。

将所有 from/to/pointer 填充到一个 any 中。毕竟，它们是并列的。

然后使用包含伪方法的 super_any。

template<class T>
struct Tparams {
  T from; T to; T* value;
};

template<class T>
Tparams<T> make_params( T from, T to, T* value ) {
  return {from, to, value};
}

template<class TEase>
auto tweener() {
  return [](auto&& Tparam, float t){
    *Tparam.value = TEase::run(t, Tparam.from, Tparam.to);
  };
}
template<class TEase>
const auto do_tween = make_any_method<void(float)>(tweener<TEase>());

template <typename TEase>
struct tween
{
  super_any<decltype(do_tween<TEase>)> Tparams;
  float _running_time;
  float _duration;
};

然后鲍勃就是你的叔叔。 live example .

template <typename TEase>
bool update(tween<TEase>& tween, float dt)
{
  float t = tween._running_time / tween._duration;
  t = (std::min)(t, 1.0f);

  (tween.Tparams->*do_tween<TEase>)(t);

  tween._running_time += dt;

  return true;
}

float value = 0;
auto test = tween<easing::linear>{make_params(0.0f, 10.0f, &value), 0.0f, 100.0f};

for (int i = 0; i < 100; ++i)
{
  update( test, 1.0 );

  std::cout << value << '\n';
}

现在我链接到的库将类型删除伪方法与 any 存储联系起来。设计不需要这个，类型删除通常也不需要伪方法技术。

我们可以将 any_methods 从 any 存储中分离出来，并手动切换哪个是事件的。

但事实上你对 any 有 3 个独立的类型删除实际上是一个设计缺陷。