Rotation.h

/*
    Hyperspace Explorer - vizualizing higher-dimensional geometry
    Copyright (C) 2010  Lene Preuss <lene.preuss@gmail.com>

    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 2 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.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/
#ifndef VECMATHROTATION_H
#define VECMATHROTATION_H

#include "Vector.h"
#include "Matrix.h"
#include "NotYetImplementedException.h"
#include "Util.h"

namespace VecMath {


    template <unsigned D> struct NumAxes {
        enum { num = NumAxes<D-1>::num+D-1 };
    };
    template <> struct NumAxes<0> { enum { num = 0 }; };
    template <> struct NumAxes<1> { enum { num = 0 }; };


    template <unsigned D> class RotationAxes {
        public:
            static unsigned axis(unsigned which, unsigned index);
        private:
            static unsigned _axis[2][NumAxes<D>::num];
    };

    template <> class RotationAxes<3> {
        public:
            static unsigned axis(unsigned which, unsigned index);
        private:
            static const unsigned _axis[2][3];  
    };

    template <> class RotationAxes<4> {
        public:
            static unsigned axis(unsigned which, unsigned index);
        private:
            static const unsigned _axis[2][6];  
    };


    class RotationBase { };


    template <unsigned D, typename N = double> class Rotation:
            public RotationBase {

        public:
          
            Rotation<D, N>();

            Rotation<D, N> (N r0, ... );

            N &operator[] (unsigned i);
            N operator[] (unsigned i) const;

            operator Matrix<D, N>() const;

            Rotation<D, N> &operator+= (const Rotation<D, N> &that);

            operator bool() const;

            const Vector<NumAxes<D>::num, N> &r() const;

            Vector<NumAxes<D>::num, N> &r();

            std::string toString() const;

        private:
          
            Vector<NumAxes<D>::num, N> axis;
    };


    //------------  important non-member functions for class Rotation

    template <unsigned D, typename N>
    Rotation<D, N> operator+ (const Rotation<D, N> &A, const Rotation<D, N> &B);

    std::ostream &operator << (std::ostream &o, const RotationBase &);

    template <unsigned D, typename N>
    std::ostream &operator << (std::ostream &o, const Rotation<D, N> &v);

    template <unsigned D, typename N>
    std::istringstream &operator >> (std::istringstream &in, Rotation<D, N> &v);

    //------------  functions that generate a Rotation without resorting to variable arglists

    template <typename N> 
    Rotation<3, N> makeRotation(N const &r0, N const &r1, N const &r2);

    template <typename N> 
    Rotation<4, N> makeRotation(N const &r0, N const &r1, N const &r2, 
                                N const &r3, N const &r4, N const &r5);
}

#endif