DarkflameServer/dCommon/NiQuaternion.h

#pragma once

// Custom Classes
#include "NiPoint3.h"

/*!
  \file NiQuaternion.hpp
  \brief Defines a quaternion in space in WXYZ coordinates
 */

class NiQuaternion;
typedef NiQuaternion Quaternion;        //!< A typedef for a shorthand version of NiQuaternion

//! A class that defines a rotation in space
class NiQuaternion {
public:
    float w;            //!< The w coordinate
    float x;            //!< The x coordinate
    float y;            //!< The y coordinate
    float z;            //!< The z coordinate
    
    
    //! The initializer
    NiQuaternion(void);
    
    //! The initializer
    /*!
      \param w The w coordinate
      \param x The x coordinate
      \param y The y coordinate
      \param z The z coordinate
     */
    NiQuaternion(float w, float x, float y, float z);
    
    //! Destructor
    ~NiQuaternion(void);
    
    // MARK: Constants
    static const NiQuaternion IDENTITY;         //!< Quaternion(1, 0, 0, 0)
    
    // MARK: Setters / Getters
    
    //! Gets the W coordinate
    /*!
      \return The w coordinate
     */
    float GetW(void) const;
    
    //! Sets the W coordinate
    /*!
      \param w The w coordinate
     */
    void SetW(float w);
    
    //! Gets the X coordinate
    /*!
      \return The x coordinate
     */
    float GetX(void) const;
    
    //! Sets the X coordinate
    /*!
      \param x The x coordinate
     */
    void SetX(float x);
    
    //! Gets the Y coordinate
    /*!
      \return The y coordinate
     */
    float GetY(void) const;
    
    //! Sets the Y coordinate
    /*!
      \param y The y coordinate
     */
    void SetY(float y);
    
    //! Gets the Z coordinate
    /*!
      \return The z coordinate
     */
    float GetZ(void) const;
    
    //! Sets the Z coordinate
    /*!
      \param z The z coordinate
     */
    void SetZ(float z);
    
    
    // MARK: Member Functions
    
    //! Returns the forward vector from the quaternion
    /*!
      \return The forward vector of the quaternion
     */
    Vector3 GetForwardVector(void) const;
    
    //! Returns the up vector from the quaternion
    /*!
      \return The up vector fo the quaternion
     */
    Vector3 GetUpVector(void) const;
    
    //! Returns the right vector from the quaternion
    /*!
      \return The right vector of the quaternion
     */
    Vector3 GetRightVector(void) const;

    Vector3 GetEulerAngles() const;
    
    
    // MARK: Operators
    
    //! Operator to check for equality
    bool operator==(const NiQuaternion& rot) const;
    
    //! Operator to check for inequality
    bool operator!=(const NiQuaternion& rot) const;
    
    
    // MARK: Helper Functions
    
    //! Look from a specific point in space to another point in space (Y-locked)
    /*!
      \param sourcePoint The source location
      \param destPoint The destination location
      \return The Quaternion with the rotation towards the destination
     */
    static NiQuaternion LookAt(const NiPoint3& sourcePoint, const NiPoint3& destPoint);
    
    //! Look from a specific point in space to another point in space
    /*!
      \param sourcePoint The source location
      \param destPoint The destination location
      \return The Quaternion with the rotation towards the destination
     */
    static NiQuaternion LookAtUnlocked(const NiPoint3& sourcePoint, const NiPoint3& destPoint);
    
    //! Creates a Quaternion from a specific axis and angle relative to that axis
    /*!
      \param axis The axis that is used
      \param angle The angle relative to this axis
      \return A quaternion created from the axis and angle
     */
    static NiQuaternion CreateFromAxisAngle(const Vector3& axis, float angle);

    static NiQuaternion FromEulerAngles(const NiPoint3& eulerAngles);
};