ipo.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2009-2015  Joerg Henrichs
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 3
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef HEADER_IPO_HPP
#define HEADER_IPO_HPP
 
#include <string>
#include <vector>
 
#include <vector2d.h>
#include <vector3d.h>
using namespace irr;
 
#include "utils/no_copy.hpp"
#include "utils/vec3.hpp"
 
class XMLNode;
 
class Ipo : public NoCopy
{
public:
    enum IpoChannelType {IPO_LOCX,   IPO_LOCY,   IPO_LOCZ,
                         IPO_LOCXYZ,
                         IPO_ROTX,   IPO_ROTY,   IPO_ROTZ,
                         IPO_SCALEX, IPO_SCALEY, IPO_SCALEZ,
                         IPO_MAX};
    static const std::string m_all_channel_names[IPO_MAX];
private:
    class IpoData
    {
    public:
        IpoChannelType m_channel;
 
        enum {IP_CONST, IP_LINEAR, IP_BEZIER}                   m_interpolation;
        enum {ET_CONST, ET_EXTRAP, ET_CYCLIC_EXTRAP, ET_CYCLIC} m_extend;
 
        std::vector<Vec3>  m_points;
 
        std::vector<Vec3>  m_handle1, m_handle2;
 
        float m_start_time;
 
        float m_end_time;
 
        Vec3 m_initial_xyz;
 
        Vec3 m_initial_hpr;
    private:
        float  getCubicBezier(float t, float p0, float p1,
                              float p2, float p3) const;
        float  getCubicBezierDerivative(float t, float p0, float p1,
                                        float p2, float p3) const;
        void approximateBezier(float t0, float t1,
                               const Vec3 &p0, const Vec3 &p1,
                               const Vec3 &h0, const Vec3 &h2,
                               unsigned int rec_level = 0);
    public:
               IpoData(const XMLNode &curve, float fps, bool reverse);
        void   readCurve(const XMLNode &node, bool reverse);
        void   readIPO(const XMLNode &node, float fps, bool reverse);
        float  approximateLength(float t0, float t1,
                                 const Vec3 &p0, const Vec3 &p1,
                                 const Vec3 &h1, const Vec3 &h2);
        float  adjustTime(float time);
        float  get(float time, unsigned int index, unsigned int n);
        float  getDerivative(float time, unsigned int index, unsigned int n);
 
    };   // IpoData
    // ------------------------------------------------------------------------
    IpoData *m_ipo_data;
 
    bool m_own_ipo_data;
 
    mutable unsigned int m_next_n;
 
    void updateNextN(float *time) const;
 
    Ipo(const Ipo *ipo);
public:
             Ipo(const XMLNode &curve, float fps=25, bool reverse=false);
    virtual ~Ipo();
    Ipo     *clone();
    void     update(float time, Vec3 *xyz=NULL, Vec3 *hpr=NULL,
                                Vec3 *scale=NULL);
    void     getDerivative(float time, Vec3 *xyz);
    float    get(float time, unsigned int index) const;
    void     setInitialTransform(const Vec3 &xyz, const Vec3 &hpr);
    void     reset();
    // ------------------------------------------------------------------------
    const std::vector<Vec3>& getPoints() const { return m_ipo_data->m_points; }
    // ------------------------------------------------------------------------
    float getEndTime() const { return m_ipo_data->m_end_time; }
};   // Ipo
 
#endif