ShMatrix.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 SH_SHMATRIX_HPP
#define SH_SHMATRIX_HPP

#include "ShMeta.hpp"
#include "ShVariable.hpp"
#include "ShAttrib.hpp"
#include "ShRefCount.hpp"

namespace SH {

template<int Rows, int Cols, ShBindingType Binding, typename T>
class ShMatrix;

template<int Rows, int Cols, typename T>
class ShMatrixRows;

template<int Rows, int Cols, ShBindingType Binding, typename T>
class ShMatrix: public virtual ShMeta {
public:
  typedef typename ShHostType<T>::type H; 
  typedef H HostType; 
    
  ShMatrix();

  ShMatrix(const ShMatrix<Rows, Cols, Binding, T>& other);


  template<ShBindingType Binding2>
  ShMatrix(const ShMatrix<Rows, Cols, Binding2, T>& other);
  
  ~ShMatrix();

  ShMatrix& operator=(const ShMatrix<Rows, Cols, Binding, T>& other);

  template<ShBindingType Binding2>
  ShMatrix& operator=(const ShMatrix<Rows, Cols, Binding2, T>& other);

  ShAttrib<Cols, Binding, T>& operator[](int i);

  const ShAttrib<Cols, Binding, T>& operator[](int i) const;

  template<ShBindingType Binding2>
  ShMatrix& operator+=(const ShMatrix<Rows, Cols, Binding2, T>& other);

  template<ShBindingType Binding2>
  ShMatrix& operator-=(const ShMatrix<Rows, Cols, Binding2, T>& other);


  template<ShBindingType Binding2>
  ShMatrix& operator/=(const ShMatrix<Rows, Cols, Binding2, T>& other);    
   

  ShMatrix<Rows - 1, Cols -1, SH_TEMP, T> subMatrix(int,int) const;

  void setTranslation(const ShGeneric<Rows-1, T>& trans);
  
  void setScaling(const ShGeneric<Rows-1, T>& scale);


  ShMatrix& operator*=(const ShGeneric<1, T>& a);
    
  ShMatrix& operator/=(const ShGeneric<1, T>& a);

  ShMatrixRows<Rows, Cols, T> operator()() const; 
  ShMatrixRows<1, Cols, T> operator()(int) const;
  ShMatrixRows<2, Cols, T> operator()(int, int) const;
  ShMatrixRows<3, Cols, T> operator()(int, int, int) const;
  ShMatrixRows<4, Cols, T> operator()(int, int, int, int) const;
  

  void range(H low, H high);

  
  virtual std::string name() const;
  virtual void name(const std::string& n);
  virtual bool has_name() const;
  
  virtual bool internal() const;
  virtual void internal(bool);

  virtual std::string title() const;
  virtual void title(const std::string& t);

  virtual std::string description() const;
  virtual void description(const std::string& d);

  virtual std::string meta(const std::string& key) const;
  virtual void meta(const std::string& key, const std::string& value);

private:
  ShAttrib<Cols, Binding, T> m_data[Rows];
  
};
template<int R, int C, ShBindingType B, typename Ty>
std::ostream& operator<<(std::ostream& out,
                         const ShMatrix<R, C, B, Ty>& m);

template<int Rows, int Cols, typename T>
class ShMatrixRows {
public:
  template<ShBindingType Binding>
  ShMatrixRows(const ShMatrix<Rows, Cols, Binding, T>& source);
  
  template<int OR, ShBindingType Binding>
  ShMatrixRows(const ShMatrix<OR, Cols, Binding, T>& source,
               int idx0);
  template<int OR, ShBindingType Binding>
  ShMatrixRows(const ShMatrix<OR, Cols, Binding, T>& source,
               int idx0, int idx1);
  template<int OR, ShBindingType Binding>
  ShMatrixRows(const ShMatrix<OR, Cols, Binding, T>& source,
               int idx0, int idx1, int idx2);
  template<int OR, ShBindingType Binding>
  ShMatrixRows(const ShMatrix<OR, Cols, Binding, T>& source,
               int idx0, int idx1, int idx2, int idx3);

  ShMatrixRows(const ShMatrixRows<Rows, Cols, T>& other);
  
  ShMatrixRows& operator=(const ShMatrixRows<Rows, Cols, T>& other);

  ShMatrix<Rows, Cols, SH_TEMP, T> operator()() const; 
  ShMatrix<Rows, 1, SH_TEMP, T> operator()(int) const;
  ShMatrix<Rows, 2, SH_TEMP, T> operator()(int, int) const;
  ShMatrix<Rows, 3, SH_TEMP, T> operator()(int, int, int) const;
  ShMatrix<Rows, 4, SH_TEMP, T> operator()(int, int, int, int) const;
private:
  ShAttrib<Cols, SH_TEMP, T> m_data[Rows];
};


typedef ShMatrix<1, 1, SH_INPUT, float> ShInputMatrix1x1f;
typedef ShMatrix<1, 1, SH_OUTPUT, float> ShOutputMatrix1x1f;
typedef ShMatrix<1, 1, SH_INOUT, float> ShInOutMatrix1x1f;
typedef ShMatrix<1, 1, SH_TEMP, float> ShMatrix1x1f;
typedef ShMatrix<1, 2, SH_INPUT, float> ShInputMatrix1x2f;
typedef ShMatrix<1, 2, SH_OUTPUT, float> ShOutputMatrix1x2f;
typedef ShMatrix<1, 2, SH_INOUT, float> ShInOutMatrix1x2f;
typedef ShMatrix<1, 2, SH_TEMP, float> ShMatrix1x2f;
typedef ShMatrix<1, 3, SH_INPUT, float> ShInputMatrix1x3f;
typedef ShMatrix<1, 3, SH_OUTPUT, float> ShOutputMatrix1x3f;
typedef ShMatrix<1, 3, SH_INOUT, float> ShInOutMatrix1x3f;
typedef ShMatrix<1, 3, SH_TEMP, float> ShMatrix1x3f;
typedef ShMatrix<1, 4, SH_INPUT, float> ShInputMatrix1x4f;
typedef ShMatrix<1, 4, SH_OUTPUT, float> ShOutputMatrix1x4f;
typedef ShMatrix<1, 4, SH_INOUT, float> ShInOutMatrix1x4f;
typedef ShMatrix<1, 4, SH_TEMP, float> ShMatrix1x4f;

typedef ShMatrix<2, 1, SH_INPUT, float> ShInputMatrix2x1f;
typedef ShMatrix<2, 1, SH_OUTPUT, float> ShOutputMatrix2x1f;
typedef ShMatrix<2, 1, SH_INOUT, float> ShInOutMatrix2x1f;
typedef ShMatrix<2, 1, SH_TEMP, float> ShMatrix2x1f;
typedef ShMatrix<2, 2, SH_INPUT, float> ShInputMatrix2x2f;
typedef ShMatrix<2, 2, SH_OUTPUT, float> ShOutputMatrix2x2f;
typedef ShMatrix<2, 2, SH_INOUT, float> ShInOutMatrix2x2f;
typedef ShMatrix<2, 2, SH_TEMP, float> ShMatrix2x2f;
typedef ShMatrix<2, 3, SH_INPUT, float> ShInputMatrix2x3f;
typedef ShMatrix<2, 3, SH_OUTPUT, float> ShOutputMatrix2x3f;
typedef ShMatrix<2, 3, SH_INOUT, float> ShInOutMatrix2x3f;
typedef ShMatrix<2, 3, SH_TEMP, float> ShMatrix2x3f;
typedef ShMatrix<2, 4, SH_INPUT, float> ShInputMatrix2x4f;
typedef ShMatrix<2, 4, SH_OUTPUT, float> ShOutputMatrix2x4f;
typedef ShMatrix<2, 4, SH_INOUT, float> ShInOutMatrix2x4f;
typedef ShMatrix<2, 4, SH_TEMP, float> ShMatrix2x4f;

typedef ShMatrix<3, 1, SH_INPUT, float> ShInputMatrix3x1f;
typedef ShMatrix<3, 1, SH_OUTPUT, float> ShOutputMatrix3x1f;
typedef ShMatrix<3, 1, SH_INOUT, float> ShInOutMatrix3x1f;
typedef ShMatrix<3, 1, SH_TEMP, float> ShMatrix3x1f;
typedef ShMatrix<3, 2, SH_INPUT, float> ShInputMatrix3x2f;
typedef ShMatrix<3, 2, SH_OUTPUT, float> ShOutputMatrix3x2f;
typedef ShMatrix<3, 2, SH_INOUT, float> ShInOutMatrix3x2f;
typedef ShMatrix<3, 2, SH_TEMP, float> ShMatrix3x2f;
typedef ShMatrix<3, 3, SH_INPUT, float> ShInputMatrix3x3f;
typedef ShMatrix<3, 3, SH_OUTPUT, float> ShOutputMatrix3x3f;
typedef ShMatrix<3, 3, SH_INOUT, float> ShInOutMatrix3x3f;
typedef ShMatrix<3, 3, SH_TEMP, float> ShMatrix3x3f;
typedef ShMatrix<3, 4, SH_INPUT, float> ShInputMatrix3x4f;
typedef ShMatrix<3, 4, SH_OUTPUT, float> ShOutputMatrix3x4f;
typedef ShMatrix<3, 4, SH_INOUT, float> ShInOutMatrix3x4f;
typedef ShMatrix<3, 4, SH_TEMP, float> ShMatrix3x4f;

typedef ShMatrix<4, 1, SH_INPUT, float> ShInputMatrix4x1f;
typedef ShMatrix<4, 1, SH_OUTPUT, float> ShOutputMatrix4x1f;
typedef ShMatrix<4, 1, SH_INOUT, float> ShInOutMatrix4x1f;
typedef ShMatrix<4, 1, SH_TEMP, float> ShMatrix4x1f;
typedef ShMatrix<4, 2, SH_INPUT, float> ShInputMatrix4x2f;
typedef ShMatrix<4, 2, SH_OUTPUT, float> ShOutputMatrix4x2f;
typedef ShMatrix<4, 2, SH_INOUT, float> ShInOutMatrix4x2f;
typedef ShMatrix<4, 2, SH_TEMP, float> ShMatrix4x2f;
typedef ShMatrix<4, 3, SH_INPUT, float> ShInputMatrix4x3f;
typedef ShMatrix<4, 3, SH_OUTPUT, float> ShOutputMatrix4x3f;
typedef ShMatrix<4, 3, SH_INOUT, float> ShInOutMatrix4x3f;
typedef ShMatrix<4, 3, SH_TEMP, float> ShMatrix4x3f;
typedef ShMatrix<4, 4, SH_INPUT, float> ShInputMatrix4x4f;
typedef ShMatrix<4, 4, SH_OUTPUT, float> ShOutputMatrix4x4f;
typedef ShMatrix<4, 4, SH_INOUT, float> ShInOutMatrix4x4f;
typedef ShMatrix<4, 4, SH_TEMP, float> ShMatrix4x4f;

}

#include "ShMatrixImpl.hpp"

#endif

---