keyFrameInterpolator.h

/****************************************************************************

 Copyright (C) 2002-2013 Gilles Debunne. All rights reserved.

 This file is part of the QGLViewer library version 2.5.2.

 http://www.libqglviewer.com - contact@libqglviewer.com

 This file may be used under the terms of the GNU General Public License 
 versions 2.0 or 3.0 as published by the Free Software Foundation and
 appearing in the LICENSE file included in the packaging of this file.
 In addition, as a special exception, Gilles Debunne gives you certain 
 additional rights, described in the file GPL_EXCEPTION in this package.

 libQGLViewer uses dual licensing. Commercial/proprietary software must
 purchase a libQGLViewer Commercial License.

 This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

*****************************************************************************/

#ifndef QGLVIEWER_KEY_FRAME_INTERPOLATOR_H
#define QGLVIEWER_KEY_FRAME_INTERPOLATOR_H

#include <QObject>
#include <QTimer>

#include "quaternion.h"
// Not actually needed, but some bad compilers (Microsoft VS6) complain.
#include "frame.h"

// If you compiler complains about incomplete type, uncomment the next line
// #include "frame.h"
// and comment "class Frame;" 3 lines below

namespace qglviewer {
class Camera;
class Frame;
class QGLVIEWER_EXPORT KeyFrameInterpolator : public QObject
{
    // todo closedPath, insertKeyFrames, deleteKeyFrame, replaceKeyFrame
    Q_OBJECT

public:
    KeyFrameInterpolator(Frame* fr=NULL);
    virtual ~KeyFrameInterpolator();

Q_SIGNALS:
    void interpolated();

    void endReached();

public Q_SLOTS:
    void addKeyFrame(const Frame& frame);
    void addKeyFrame(const Frame& frame, float time);

    void addKeyFrame(const Frame* const frame);
    void addKeyFrame(const Frame* const frame, float time);

    void deletePath();

public:
    Frame* frame() const { return frame_; }

public Q_SLOTS:
    void setFrame(Frame* const frame);

public:
    Frame keyFrame(int index) const;
    float keyFrameTime(int index) const;
    int numberOfKeyFrames() const { return keyFrame_.count(); }
    float duration() const;
    float firstTime() const;
    float lastTime() const;

public:
    float interpolationTime() const { return interpolationTime_; }
    float interpolationSpeed() const { return interpolationSpeed_; }
    int interpolationPeriod() const { return period_; }
    bool loopInterpolation() const { return loopInterpolation_; }
#ifndef DOXYGEN

    bool closedPath() const { return closedPath_; }
#endif
public Q_SLOTS:
    void setInterpolationTime(float time) { interpolationTime_ = time; }
    void setInterpolationSpeed(float speed) { interpolationSpeed_ = speed; }
    void setInterpolationPeriod(int period) { period_ = period; }
    void setLoopInterpolation(bool loop=true) { loopInterpolation_ = loop; }
#ifndef DOXYGEN

    void setClosedPath(bool closed=true) { closedPath_ = closed; }
#endif



public:
    bool interpolationIsStarted() const { return interpolationStarted_; }
public Q_SLOTS:
    void startInterpolation(int period = -1);
    void stopInterpolation();
    void resetInterpolation();
    void toggleInterpolation() { if (interpolationIsStarted()) stopInterpolation(); else startInterpolation(); }
    virtual void interpolateAtTime(float time);

public:
    virtual void drawPath(int mask=1, int nbFrames=6, float scale=1.0f);

public:
    virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
    virtual void initFromDOMElement(const QDomElement& element);

private Q_SLOTS:
    virtual void update();
    virtual void invalidateValues() { valuesAreValid_ = false; pathIsValid_ = false; splineCacheIsValid_ = false; }

private:
    // Copy constructor and opertor= are declared private and undefined
    // Prevents everyone from trying to use them
    // KeyFrameInterpolator(const KeyFrameInterpolator& kfi);
    // KeyFrameInterpolator& operator=(const KeyFrameInterpolator& kfi);

    void updateCurrentKeyFrameForTime(float time);
    void updateModifiedFrameValues();
    void updateSplineCache();

#ifndef DOXYGEN
    // Internal private KeyFrame representation
    class KeyFrame
    {
    public:
        KeyFrame(const Frame& fr, float t);
        KeyFrame(const Frame* fr, float t);

        Vec position() const { return p_; }
        Quaternion orientation() const { return q_; }
        Vec tgP() const { return tgP_; }
        Quaternion tgQ() const { return tgQ_; }
        float time() const { return time_; }
        const Frame* frame() const { return frame_; }
        void updateValuesFromPointer();
        void flipOrientationIfNeeded(const Quaternion& prev);
        void computeTangent(const KeyFrame* const prev, const KeyFrame* const next);
    private:
        Vec p_, tgP_;
        Quaternion q_, tgQ_;
        float time_;
        const Frame* const frame_;
    };
#endif

    // K e y F r a m e s
    mutable QList<KeyFrame*> keyFrame_;
    QMutableListIterator<KeyFrame*>* currentFrame_[4];
    QList<Frame> path_;

    // A s s o c i a t e d   f r a m e
    Frame* frame_;

    // R h y t h m
    QTimer timer_;
    int period_;
    float interpolationTime_;
    float interpolationSpeed_;
    bool interpolationStarted_;

    // M i s c
    bool closedPath_;
    bool loopInterpolation_;

    // C a c h e d   v a l u e s   a n d   f l a g s
    bool pathIsValid_;
    bool valuesAreValid_;
    bool currentFrameValid_;
    bool splineCacheIsValid_;
    Vec v1, v2;
};

} // namespace qglviewer

#endif // QGLVIEWER_KEY_FRAME_INTERPOLATOR_H