ShQuaternion.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2005 Serious Hack Inc.
// 
// 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., 51 Franklin Street, Fifth Floor, Boston, 
// MA  02110-1301, USA
#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 ShAttrib<4, B2, T, SH_VECTOR>& values);
  
  
  template<ShBindingType B2, ShBindingType B3>
  ShQuaternion(const ShAttrib<1, B2, T>& angle, 
               const ShAttrib<3, B3, T, SH_VECTOR>& 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 ShAttrib<3, B2, T, SH_VECTOR>& right);
  
  template<ShBindingType B2>
  ShQuaternion& operator*=(const ShAttrib<3, B2, T, SH_NORMAL>& 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 ShAttrib<3, B2, T, SH_VECTOR>& q2);
  
  template<ShBindingType B2>
  ShQuaternion<SH_TEMP, T> operator*(const ShAttrib<3, B2, T, SH_NORMAL>& 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;

  ShAttrib<4, SH_TEMP, T, SH_VECTOR> getVector() const;
private:
  ShAttrib<4, B, T, SH_VECTOR> 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

---