spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Template Instantiation Test with "Visual C++ 2013" (C++11)
// 18/10/2014 by Lukas Hermanns

#include <iostream>
#include <cstdlib>


/* --- Global constants --- */

static const float pi       = 3.14159265359f;
static const double pi64    = 3.1415926535897932384626433832795028841971693993751;


/* --- Angle base class --- */

/**
Angle base class. This class stores a value in common angle units which can be converted into radians or degrees.
The internal angle units are in the range [0.0 .. 1.0), i.e. 1.0 is a 360 degrees, or rather a 2*pi radians rotation.
\tparam T Specifies the data type. This should be float or double.
\tparam Definition Specifies the definition of a full rotation. This must be a struct that implements the following interface:
\code
struct ExampleDefinition
{
    // Full rotation. This can be 1.0 (for abstract abgles), 360.0 (for degrees) or 2*PI<T>() (for radians).
    static T FullRotation();
};
\endcode
*/
template <typename T, class Definition> class AngleBase
{
    
    public:
        
        typedef AngleBase<T, Definition> ThisType;

        AngleBase() = default;
        //! Constructor for implicit conversion between angle definitions.
        template <typename OtherDefinition> AngleBase(const AngleBase<T, OtherDefinition>& other) :
            angle_{ other.NormalizedAngle() * ThisType::FullRotation() }
        {
        }
        explicit AngleBase(const T& angleUnits) :
            angle_{ angleUnits }
        {
        }

        inline ThisType& operator += (const ThisType& other)
        {
            angle_ += other.angle_;
            return *this;
        }
        inline ThisType& operator -= (const ThisType& other)
        {
            angle_ -= other.angle_;
            return *this;
        }

        inline ThisType& operator *= (const T& factor)
        {
            angle_ *= factor;
            return *this;
        }
        inline ThisType& operator /= (const T& factor)
        {
            angle_ /= factor;
            return *this;
        }

        /**
        Converts this angle to an angle of the other angle type.
        \tparam OtherType This must be an "AngleBase" class, e.g. Angle, Degree or Radian.
        \return The converted angle.
        \note There is a BUG inside the MSVC12 compiler which instantiates this function wrong!
        This happens when this function is called consecutively with different template arguments.
        This totally works for GCC 4.7+ but unfortunately not correctly for MSVC12.
        */
        template <template <typename> class OtherType> inline T Get() const
        {
            return NormalizedAngle() * OtherType<T>::FullRotation();
        }

        //! Returns the internal angle. This value depends on the angle definition.
        inline T GetAngle() const
        {
            return angle_;
        }

        //! Returns the normalized angle, i.e. in the range [0.0 .. 1.0).
        inline T NormalizedAngle() const
        {
            return angle_ / ThisType::FullRotation();
        }

        /**
        Returns the full rotation of this angle definition.
        This can be 1.0 (for unit angles), 360 (for degrees) or 2*pi (for radians).
        */
        static inline T FullRotation()
        {
            return Definition::FullRotation();
        }

    private:

        T angle_ { 0 };

};


/* --- Global "AngleBase" operators --- */

template <typename T, class DefinitionLHS, class DefinitionRHS>
AngleBase<T, DefinitionLHS> operator + (const AngleBase<T, DefinitionLHS>& lhs, const AngleBase<T, DefinitionRHS>& rhs)
{
    auto result = lhs;
    result += AngleBase<T, DefinitionLHS>(rhs);
    return result;
}

template <typename T, class DefinitionLHS, class DefinitionRHS>
AngleBase<T, DefinitionLHS> operator - (const AngleBase<T, DefinitionLHS>& lhs, const AngleBase<T, DefinitionRHS>& rhs)
{
    auto result = lhs;
    result -= AngleBase<T, DefinitionLHS>(rhs);
    return result;
}

template <typename T, class Definition> AngleBase<T, Definition> operator * (const AngleBase<T, Definition>& lhs, const T& rhs)
{
    auto result = lhs;
    result *= rhs;
    return result;
}
template <typename T, class Definition> AngleBase<T, Definition> operator * (const T& lhs, const AngleBase<T, Definition>& rhs)
{
    auto result = rhs;
    result *= lhs;
    return result;
}

template <typename T, class Definition> AngleBase<T, Definition> operator / (const AngleBase<T, Definition>& lhs, const T& rhs)
{
    auto result = lhs;
    result /= rhs;
    return result;
}
template <typename T, class Definition> AngleBase<T, Definition> operator / (const T& lhs, const AngleBase<T, Definition>& rhs)
{
    auto result = rhs;
    result /= lhs;
    return result;
}


/* --- Angle --- */

//! Angle rotation definition.
template <typename T> struct AngleDefinition
{
    static inline T FullRotation()
    {
        return T(1);
    }
};

//! AngleBase specialization for unit angles in the range [0.0 .. 1.0).
template <typename T = float> using Angle = AngleBase<T, AngleDefinition<T>>;


/* --- Degree --- */

//! Degree rotation definition.
template <typename T> struct DegreeDefinition
{
    static inline T FullRotation()
    {
        return T(360);
    }
};

//! AngleBase specialization for degrees in the range [0.0 .. 360).
template <typename T = float> using Degree = AngleBase<T, DegreeDefinition<T>>;


/* --- Radian --- */

//! Radian rotation definition.
template <typename T> struct RadianDefinition
{
    static inline T FullRotation()
    {
        return T(pi64*2.0);
    }
};

//! AngleBase specialization for radians in the range [0.0 .. 2*pi).
template <typename T = float> using Radian = AngleBase<T, RadianDefinition<T>>;


/* --- Main function --- */

int main()
{
    // Abstract angle in the range [0.0 .. 1.0),
    // constructed by (90 degrees) + (pi/2 radians) = 0.5 (half rotation).
    Angle<float> angle = Degree<float>(90.0f) + Radian<float>(pi/2);

    #if 1

    auto degree = angle.Get<Degree>();
    auto radian = angle.Get<Radian>(); // MSVC COMPILER FAILURE -> angle.Get<Degree> will be instantiated but angle.Get<Radian> is required !!!

    std::cout << "Angle = " << angle.GetAngle() << std::endl;
    std::cout << "Degree = " << degree << std::endl;
    std::cout << "Radian = " << radian << std::endl;

    #else

    auto radian = angle.Get<Radian>();
    auto degree = angle.Get<Degree>(); // MSVC COMPILER FAILURE -> angle.Get<Radian> will be instantiated but angle.Get<Degree> is required !!!

    std::cout << "Angle = " << angle.GetAngle() << std::endl;
    std::cout << "Degree = " << degree << std::endl;
    std::cout << "Radian = " << radian << std::endl;

    #endif

    system("pause");
    return 0;
}

C-/C++-Quelltext

auto degree = Degree<float>();
auto radian = degree.Get<Radian>();

C-/C++-Quelltext

auto degree = Degree<float>();
auto radian = degree.Get<Radian<float>>();