MPath.h

Go to the documentation of this file.

//    Copyright (C) 2004-2012 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    This library 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
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef MPATH_H
#define MPATH_H

#include "MPoint.h"

#include <vector>

namespace OpenSkyNet {
    namespace Math {
        class Path {
            bool _pathChanged;
            Utils::uint _numPoints;
            float _totalDist;
            std::vector<Math::Point<> > _points;
            std::vector<float> _dist;
        public:
            Path();

            inline Utils::uint getNumPoints() const { return _numPoints; }
            inline std::vector<Math::Point<> >& getPoints() { return _points; }
            inline const std::vector<Math::Point<> >& getPoints() const { return _points; }

            inline Utils::uint addAPoint(const Math::Point<>& aPoint_) {
                _points.push_back(aPoint_);
                if (_numPoints > 0) {
                    _dist.push_back((aPoint_ - _points[_numPoints-1]).getLength());
                    _totalDist += _dist[_numPoints-1];
                }
                ++_numPoints;
                _pathChanged = true;
                return (_numPoints - 1);
            }

            inline Utils::uint addAPoint(float x_, float y_, float z_) { return addAPoint(Math::Point<>(x_,y_,z_)); }

            inline Utils::uint appendPath(const Path& path_) {
                for (Utils::uint i = 0; i < path_.getNumPoints(); i++)
                    addAPoint(path_.getPoints()[i]);
                return (_numPoints - 1);
            }

            inline void clear() {
                _points.clear();
                _dist.clear();
                _numPoints = 0;
                _totalDist = 0;
                _pathChanged = true;
            }

            inline bool isPathChanged() {
                if (_pathChanged) {
                    _pathChanged = false;
                    return true;
                }
                return false;
            }

            inline void translate(const Math::Point<>& p_) {
                for (Utils::uint i = 0; i < _numPoints; i++)
                    _points[i] = _points[i] + p_;
                _pathChanged = true;
            }

            void calcNaturalCubicSpline(float minDistanceBetweenPoints_=1.0, Utils::uint maxTotalPoints_=0, float tension_=0.0f);

            void calcDistances();

            inline float getTotalDist() const { return _totalDist; }

            Math::Point<> travelPercentOfPoints(const float& percent_) const;
            Math::Point<> travelPercentOfDist(const float& percent_) const;

            float getAdditiveFromSpeed(float speed_) const { return speed_ / _totalDist; }
        };
    }
}

#endif //MPATH_H