MPoint.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 MPOINT_H
#define MPOINT_H

#include "MFun.h"

#include <string.h> //for memset()
#include <algorithm> //for max()

namespace OpenSkyNet {
    namespace Math {
        template<class T=float, unsigned char U=3>
        class Point {
        public:
            T _dimensions[U];

            Point(const T& x_=0, const T& y_=0, const T& z_=0) {
                assert(U >= 1);
                memset(_dimensions,0,sizeof(T)*U);
                switch (U) {
                    case 1:
                        _dimensions[0] = x_;
                    break;
                    case 2:
                        _dimensions[0] = x_;
                        _dimensions[1] = y_;
                    break;
                    default:
                        _dimensions[0] = x_;
                        _dimensions[1] = y_;
                        _dimensions[2] = z_;
                    break;
                }
            }

            Point(const Point<T>& p_) {
                for (unsigned char i = 0; i < U; ++i)
                    _dimensions[i] = p_._dimensions[i];
            }

            inline unsigned char getNumDimensions() const { return U; }
            inline T& x() { return _dimensions[0]; }
            inline T& y() { return _dimensions[1]; }
            inline T& z() { return _dimensions[2]; }
            inline T& r() { return _dimensions[0]; }
            inline T& g() { return _dimensions[1]; }
            inline T& b() { return _dimensions[2]; }
            inline T& a() { return _dimensions[3]; }
            inline T& operator[](int i_) { return _dimensions[i_]; }
            inline const T& x() const { return _dimensions[0]; }
            inline const T& y() const { return _dimensions[1]; }
            inline const T& z() const { return _dimensions[2]; }
            inline const T& r() const { return _dimensions[0]; }
            inline const T& g() const { return _dimensions[1]; }
            inline const T& b() const { return _dimensions[2]; }
            inline const T& a() const { return _dimensions[3]; }
            inline const T& operator[](int i_) const { return _dimensions[i_]; }

            inline Point<T> operator-() const {
                Point<T> result(*this);
                for (unsigned char i = 0; i < U; ++i)
                    result._dimensions[i] = -result._dimensions[i];
                return result;
            }

            inline Point<T> getAbs() const {
                Point<T> result(*this);
                for (unsigned char i = 0; i < U; ++i)
                    if (result._dimensions[i] < 0)
                        result._dimensions[i] = -result._dimensions[i];
                return result;
            }

            inline T getComponentSum() const {
                T sum = 0;
                for (unsigned char i = 0; i < U; ++i)
                    sum += _dimensions[i];
                return sum;
            }

            inline T getMax() const {
                T max = _dimensions[0];
                for (unsigned char i = 1; i < U; ++i)
                    if (_dimensions[i] > max)
                        max = _dimensions[i];
                return max;
            }

            inline T getMin() const {
                T min = _dimensions[0];
                for (unsigned char i = 1; i < U; ++i)
                    if (_dimensions[i] < min)
                        min = _dimensions[i];
                return min;
            }

            inline T getLenSqrd() const {
                T length = 0;
                for (unsigned char i = 0; i < U; ++i)
                    length += _dimensions[i]*_dimensions[i];
                return length;
            }

            inline T getLength() const { return (static_cast<T>(sqrt(getLenSqrd()))); }

            inline void normalize() {
                T lensqrd = getLenSqrd();
                if (lensqrd) {
                    T len = static_cast<T>(sqrt(lensqrd));
                    for (unsigned char i = 0; i < U; ++i)
                        _dimensions[i] /= len;
                }
            }

            inline bool equals(const Point<T>& rhs_, T radiusSqrd_) const {
                if ((rhs_ - *this).getLenSqrd() > radiusSqrd_)
                    return false;
                return true;
            }

            inline Point<T,U>& operator=(const Point<T,U>& rhs_) {
                for (unsigned char i = 0; i < U; ++i)
                    _dimensions[i] = rhs_._dimensions[i];
                return *this;
            }

            inline Point<T>& operator+=(const Point<T>& rhs_) {
                for (unsigned char i = 0; i < U; ++i)
                    _dimensions[i] = _dimensions[i] + rhs_._dimensions[i];
                return *this;
            }

            inline Point<T>& operator+=(const T& rhs_) {
                for (unsigned char i = 0; i < U; ++i)
                    _dimensions[i] = _dimensions[i] + rhs_;
                return *this;
            }

            inline Point<T>& operator-=(const Point<T>& rhs_) { return (*this)+=(-rhs_); }

            inline Point<T>& operator-=(const T& rhs_) {
                for (unsigned char i = 0; i < U; ++i)
                    _dimensions[i] = _dimensions[i] - rhs_;
                return *this;
            }

            inline Point<T>& operator*=(const T& rhs_) {
                for (unsigned char i = 0; i < U; ++i)
                    _dimensions[i] = _dimensions[i] * rhs_;
                return *this;
            }

            inline Point<T> getCross3(const Point<T>& rhs_) const {
                return Point<T>(y()*rhs_.z() - z()*rhs_.y(), z()*rhs_.x() - x()*rhs_.z(), x()*rhs_.y() - y()*rhs_.x());
            }

            inline T getDot3(const Point<T>& rhs_) const {
                return (x()*rhs_.x() + y()*rhs_.y() + z()*rhs_.z());
            }

            inline Point<T> getReflection3(const Point<T>& n_) const {
                Point<T> projection(n_ * getDot3(n_));
                return *this - (projection * 2.f);
            }
        };

        extern const Math::Point<> g_origin;
        extern const Math::Point<> g_xAxis;
        extern const Math::Point<> g_yAxis;
        extern const Math::Point<> g_zAxis;

        template<class T, class U>
        inline bool operator==(const Point<T>& lhs_, const Point<U>& rhs_) {
            bool result = true;
            for (unsigned char i = 0; i < lhs_.getNumDimensions(); ++i) {
                if (lhs_._dimensions[i] != rhs_._dimensions[i]) {
                    result = false;
                    break;
                }
            }
            return result;
        }

        template<class T, class U>
        inline bool operator!=(const Point<T>& lhs_, const Point<U>& rhs_) { return (!(lhs_ == rhs_)); }

        template<class T, class U>
        inline Point<T> operator+(const Point<T>& lhs_, const Point<U>& rhs_) {
            unsigned char dimensToAdd = lhs_.getNumDimensions();
            Point<T> result;
            for (unsigned char i = 0; i < dimensToAdd; ++i)
                result._dimensions[i] = lhs_._dimensions[i] + rhs_._dimensions[i];
            return result;
        }

        template<class T, class U>
        inline Point<T> operator-(const Point<T>& lhs_, const Point<U>& rhs_) { return (lhs_ + -rhs_); }

        template<class T, class U>
        inline Point<T> operator*(const Point<T>& lhs_, const Point<U>& rhs_) {
            unsigned char dimensToMul = lhs_.getNumDimensions();
            Point<T> result;
            for (unsigned char i = 0; i < dimensToMul; ++i)
                result._dimensions[i] = lhs_._dimensions[i] * rhs_._dimensions[i];
            return result;
        }

        template<class T, class U>
        inline Point<T> operator/(const Point<T>& lhs_, const Point<U>& rhs_) {
            unsigned char dimensToDiv = lhs_.getNumDimensions();
            Point<T> result;
            for (unsigned char i = 0; i < dimensToDiv; ++i)
                result._dimensions[i] = lhs_._dimensions[i] / rhs_._dimensions[i];
            return result;
        }

        template<class T, class U>
        inline Point<T> operator*(const Point<T>& lhs_, const U& rhs_) {
            Point<T> result;
            for (unsigned char i = 0; i < lhs_.getNumDimensions(); ++i)
                result._dimensions[i] = lhs_._dimensions[i] * rhs_;
            return result;
        }

        template<class T, class U>
        inline Point<T> operator/(const Point<T>& lhs_, const U& rhs_) {
            Point<T> result;
            for (unsigned char i = 0; i < lhs_.getNumDimensions(); ++i)
                result._dimensions[i] = lhs_._dimensions[i] / rhs_;
            return result;
        }

        template<class T, class U>
        inline T getLength(const Point<T>& lhs_, const Point<U>& rhs_) { return (rhs_ - lhs_).getLength(); }

        template<class T, class U>
        inline Point<T> interpolate(const Point<T>& lhs_, const Point<U>& rhs_, float amount_) {
            Math::clamp<float>(amount_);
            return Point<T>((lhs_ * (1.0f - amount_)) + (rhs_ * amount_));
        }

        inline Point<float,2> RandPointInOrOnCircle(float radius_) {
            Point<float,2> p;
            const float radiusSqrd = radius_ * radius_;

            //the probability of needing more than k tries is (1-PI/4)^k. For k=20, this is ~ 0.00000000000004
            for (int n = 0; n < 20; ++n) {
                p.x() = radius_ * randNeg1Pos1();
                p.y() = radius_ * randNeg1Pos1();
                if (p.getLenSqrd() <= radiusSqrd)
                    return p;
            }

            float rads = 2.0f * PI * rand01();
            float dist = rand01() + rand01();
            if (dist > 1.f)
                dist = 2.f - dist;

            p.x() = radius_ * dist * cosf(rads);
            p.y() = radius_ * dist * sinf(rads);

            return p;
        }
    }
}

#endif //MPOINT_H