keyFrameInterpolator.h

Go to the documentation of this file.

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

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

 This file is part of the QGLViewer library version 2.6.3.

 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, qreal time);

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

        void deletePath();

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

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

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

public:
        qreal interpolationTime() const { return interpolationTime_; }
        qreal 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(qreal time) { interpolationTime_ = time; }
        void setInterpolationSpeed(qreal 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(qreal time);

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

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(qreal time);
        void updateModifiedFrameValues();
        void updateSplineCache();

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

                Vec position() const { return p_; }
                Quaternion orientation() const { return q_; }
                Vec tgP() const { return tgP_; }
                Quaternion tgQ() const { return tgQ_; }
                qreal 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_;
                qreal 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_;
        qreal interpolationTime_;
        qreal 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