ShQuaternion.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright (c) 2003 University of Waterloo Computer Graphics Laboratory
// Project administrator: Michael D. McCool
// Authors: Zheng Qin, Stefanus Du Toit, Kevin Moule, Tiberiu S. Popa,
//          Michael D. McCool
// 
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// 
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 
// 1. The origin of this software must not be misrepresented; you must
// not claim that you wrote the original software. If you use this
// software in a product, an acknowledgment in the product documentation
// would be appreciated but is not required.
// 
// 2. Altered source versions must be plainly marked as such, and must
// not be misrepresented as being the original software.
// 
// 3. This notice may not be removed or altered from any source
// distribution.
#ifndef SHQUATERNION_HPP
#define SHQUATERNION_HPP

#include <iostream>
#include "ShLib.hpp"

namespace SH {

template<ShBindingType B, typename T = float>
class ShQuaternion
{
  template <ShBindingType B2, typename T2>
  friend std::ostream& operator<<(std::ostream& out, 
                                  const ShQuaternion<B2, T2>& q);
public:
  typedef typename ShHostType<T>::type HostType;
  
  ShQuaternion();

  template<ShBindingType B2> 
  ShQuaternion(const ShQuaternion<B2, T>& other);

  
  template<ShBindingType B2>
  ShQuaternion(const ShVector<4, B2, T>& values);
  
  
  template<ShBindingType B2, ShBindingType B3>
  ShQuaternion(const ShAttrib<1, B2, T>& angle, 
               const ShVector<3, B3, T>& axis);
  
  
  template<ShBindingType B2>
  ShQuaternion(const ShMatrix<4, 4, B2, T>& mat);
  
  template<ShBindingType B2> 
  ShQuaternion& operator=(const ShQuaternion<B2, T>& other);

  template<ShBindingType B2>
  ShQuaternion& operator+=(const ShQuaternion<B2, T>& right);
  
  template<ShBindingType B2>
  ShQuaternion& operator-=(const ShQuaternion<B2, T>& right);
  
  template<ShBindingType B2>
  ShQuaternion& operator*=(const ShQuaternion<B2, T>& right);

  
  template<ShBindingType B2>
  ShQuaternion& operator*=(const ShAttrib<1, B2, T>& right);
  
  template<ShBindingType B2>
  ShQuaternion& operator*=(const ShVector<3, B2, T>& right);
  
  template<ShBindingType B2>
  ShQuaternion& operator*=(const ShNormal<3, B2, T>& right);

  template<ShBindingType B2>
  ShQuaternion<SH_TEMP, T> operator+(const ShQuaternion<B2, T>& q2);
  
  template<ShBindingType B2>
  ShQuaternion<SH_TEMP, T> operator-(const ShQuaternion<B2, T>& q2);

  template<ShBindingType B2>
  ShQuaternion<SH_TEMP, T> operator*(const ShQuaternion<B2, T>& q2);
  
  template<ShBindingType B2>
  ShQuaternion<SH_TEMP, T> operator*(const ShAttrib<1, B2, T>& c);
  
  template<ShBindingType B2>
  ShQuaternion<SH_TEMP, T> operator*(const ShVector<3, B2, T>& q2);
  
  template<ShBindingType B2>
  ShQuaternion<SH_TEMP, T> operator*(const ShNormal<3, B2, T>& q2);

  void normalize();
  
  void getValues(HostType values []) const;

  void setUnit(bool flag);

  void name(const std::string& name);
  
  std::string name() const; 

  template<ShBindingType B2>
  ShAttrib<1, SH_TEMP, T> dot(const ShQuaternion<B2, T>& q) const;
  
  ShQuaternion<SH_TEMP, T> conjugate() const;
  
  ShQuaternion<SH_TEMP, T> inverse() const;
  
  ShMatrix<4, 4, SH_TEMP, T> getMatrix() const;

  ShVector<4, SH_TEMP, T> getVector() const;
private:
  ShVector<4, B, T> m_data;
};

template<ShBindingType B, typename T, ShBindingType B2>
extern ShQuaternion<SH_TEMP, T> 
operator*(const ShAttrib<1, B2, T>& c, const ShQuaternion<B, T>& q); 

template<ShBindingType B1, ShBindingType B2, typename T>
extern ShQuaternion<SH_TEMP, T>
slerp(const ShQuaternion<B1, T>& q1, const ShQuaternion<B2, T>& q2, 
    const ShAttrib1f& t);

typedef ShQuaternion<SH_INPUT, float> ShInputQuaternionf;
typedef ShQuaternion<SH_OUTPUT, float> ShOutputQuaternionf;
typedef ShQuaternion<SH_TEMP, float> ShQuaternionf;
}

#include "ShQuaternionImpl.hpp"

#endif

---