闲谈原型模式——基于UI动画框架

  前几篇文章介绍了CEGUI动画框架中主要的几个设计模式。本文接着讨论“原型模式”在动画框架中的应用。

1. 原型模式

  原型模式的定义：

用原型实例指定创建对象的种类，通过拷贝这些原型创建新的对象。

  类图：

  Prototype：声明一个可以复制自身的接口，用来约束想要复制自身的类，要求它们都要实现Clone方法。

  ConcretePrototypeX：实现Prototype接口的类，这些类真正实现了复制自身的功能。

  Client：使用原型的客户端，调用原型实例对象（可能并不知道具体类型）的Clone方法来创建新的对象实例。

  C++中，Prototype继承体系中的Clone方法是个虚函数，而派生类中的Clone方法可能需要返回自身类型的指针，正好可以利用C++的协变返回机制。上面的类图中ConcretePrototypeX实现的Clone接口的返回值类型写成了自身类型的指针也是有意为之。

2. 框架中的应用

2.1. 动画原型模式

  我们在xml文件中配置的动画（代码），实际上只是一个模板，在程序启动时加载这些配置到内存中，经过解释器解释之后，以抽象语法树的形式存在；在运行时，并不是将这棵树拿来直接使用，而是用这棵树的一个副本来驱动窗口动画。我们先看一下单一动画：

class SingleAnimation : public Animation
{
private:
    virtual SingleAnimation* Clone() const // 协变机制返回    
    {
        SingleAnimation* sa = new SingleAnimation(clipped);
        sa->strategy = strategy->Clone();	
        return sa;
    }

private:
    bool                clipped;   // 是否被父窗口裁剪
    Window*             aniWnd;    // 动画窗口对象
    IStrategy*          strategy;  // 动画的控制策略
};

因为同一个动画效果可能同时作用在不同的窗口上，因此需要用动画模板的副本。而对于客户代码来说，并不知道这个动画模板是SingleAnimation动画还是GroupAnimation动画，或者GroupAnimation是GroupAnimationSerial还是GroupAnimationParallel，客户代码只需要当前动画模板的一个副本，它能做的，就是一句话：我需要你的一个副本，你帮忙复制一下你自己吧。来看一下动画组的Clone接口：

// 串行动画组
GroupAnimationSerial* GroupAnimationSerial::Clone() const
{
    GroupAnimationSerial* gas = new GroupAnimationSerial();
    for (auto animation : animations)
        gas->AddAnimation(animation->Clone());

    return gas;
}

// 并行动画组
GroupAnimationParallel* GroupAnimationParallel::Clone() const
{
    GroupAnimationParallel* gap = new GroupAnimationParallel();
    for (auto animation : animations)
        gap->AddAnimation(animation->Clone());

    return gap;
}

  动画类的原型模式类图：

  代码中可以看到，单一动画的Clone接口中，动画的控制策略字段也进行复制了：

sa->strategy = strategy->Clone();

因此动画策略也使用了“原型模式”。

2.2. 策略原型模式

  因为动画策略也是一个模板，同一个策略效果可能会同时作用在不同的窗口上，因此使用原型模式也是很自然的选择：

class IStrategy
{
public:
    // 同一个策略可能会有多个实例，因此需要一个Clone
    virtual IStrategy* Clone() const = 0;
};

class FadeStrategy : public IStrategy
{
private:
    virtual FadeStrategy* Clone() const // 协变机制返回
    {
        return new FadeStrategy(iniAlpha, delta, minAlpha, maxAlpha);
    }

private:
    const float  iniAlpha;      // alpha初始值
    float        delta;         // 帧与帧之间的alpha变化的百分比
    const float  minAlpha;      // alpha的下限
    const float  maxAlpha;      // alpha的上限
};

再看一下策略组的Clone接口：

class Strategys : public IStrategy
{
protected:
    std::vector<IStrategy*> strategys;
    int             times; // 策略组施加控制的次数，默认为1次
    const int       ctimes; // 用于恢复
};

// 串行策略组
class StrategysSerial : public Strategys
{
private:
    virtual StrategysSerial* Clone()
    {
        // 0初始化cur，times, ctimes分别初始化基类Strategys的对应字段
        StrategysSerial* ss = new StrategysSerial(0, times, ctimes);
        for (auto s : strategys)
            ss->AddStrategy(s->Clone());

        return ss;
    }

private:
    int  cur; // 当前正在施加控制的策略的索引
};

// 并行策略组
class StrategysParallel : public Strategys
{
private:
    virtual StrategysParallel* Clone()
    {
        // times, ctimes分别初始化基类Strategys的对应字段
        StrategysParallel* sp = new StrategysParallel(times, ctimes);
        for (auto s : strategys)
            sp->AddStrategy(s->Clone());

        sp->cur = sp->strategys.begin();
        return sp;
    }

private:
    std::vector<IStrategy*>::const_iterator cur; // 当前执行到哪个策略，下一帧从这个策略开始继续执行
};

类图：

3. 结语

  原型模式的本质是复制对象，只有各具体派生类自己才清楚地知道怎么复制自己，从而产生一个副本；因此在不知道对象的具体类型时想要对象的一个副本的情况下，可以考虑原型模式。