[occt.git] / src / NCollection / NCollection_Mat4.hxx

// Created on: 2013-05-30
// Created by: Anton POLETAEV
// Copyright (c) 2013 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and / or modify it
// under the terms of the GNU Lesser General Public version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#ifndef _NCollection_Mat4_HeaderFile
#define _NCollection_Mat4_HeaderFile

#include <NCollection_Vec4.hxx>

//! Generic matrix of 4 x 4 elements.
//! To be used in conjunction with NCollection_Vec4 entities.
//! Originally introduced for 3D space projection and orientation
//! operations.
template<typename Element_t>
class NCollection_Mat4
{

public:

  //! Get number of rows.
  //! @return number of rows.
  static size_t Rows()
  {
    return 4;
  }

  //! Get number of columns.
  //! @retur number of columns.
  static size_t Cols()
  {
    return 4;
  }

  //! Empty constructor.
  //! Construct the zero matrix.
  NCollection_Mat4()
  {
    InitIdentity();
  }

  //! Copy constructor.
  //! @param theOther [in] the matrix to copy values from.
  NCollection_Mat4 (const NCollection_Mat4& theOther)
  {
    std::memcpy (this, &theOther, sizeof (NCollection_Mat4));
  }

  //! Assignment operator.
  //! @param theOther [in] the matrix to copy values from.
  const NCollection_Mat4& operator= (const NCollection_Mat4& theOther)
  {
    std::memcpy (this, &theOther, sizeof (NCollection_Mat4));
    return *this;
  }

  //! Get element at the specified row and column.
  //! @param theRow [in] the row.to address.
  //! @param theCol [in] the column to address.
  //! @return the value of the addressed element.
  Element_t GetValue (const size_t theRow, const size_t theCol) const
  {
    return myMat[theCol * 4 + theRow];
  }

  //! Access element at the specified row and column.
  //! @param theRow [in] the row.to access.
  //! @param theCol [in] the column to access.
  //! @return reference on the matrix element.
  Element_t& ChangeValue (const size_t theRow, const size_t theCol)
  {
    return myMat[theCol * 4 + theRow];
  }

  //! Set value for the element specified by row and columns.
  //! @param theRow   [in] the row to change.
  //! @param theCol   [in] the column to change.
  //! @param theValue [in] the value to set.s
  void SetValue (const size_t    theRow,
                 const size_t    theCol,
                 const Element_t theValue)
  {
    myMat[theCol * 4 + theRow] = theValue;
  }

  //! Get vector of elements for the specified row.
  //! @param theRow [in] the row to access.
  //! @return vector of elements.
  NCollection_Vec4<Element_t> GetRow (const size_t theRow) const
  {
    return NCollection_Vec4<Element_t> (GetValue (theRow, 0),
                                        GetValue (theRow, 1),
                                        GetValue (theRow, 2),
                                        GetValue (theRow, 3));
  }

  //! Change first 3 row values by the passed vector.
  //! @param theRow [in] the row to change.
  //! @param theVec [in] the vector of values.
  void SetRow (const size_t theRow, const NCollection_Vec3<Element_t>& theVec)
  {
    SetValue (theRow, 0, theVec.x());
    SetValue (theRow, 1, theVec.y());
    SetValue (theRow, 2, theVec.z());
  }

  //! Set row values by the passed 4 element vector.
  //! @param theRow [in] the row to change.
  //! @param theVec [in] the vector of values.
  void SetRow (const size_t theRow, const NCollection_Vec4<Element_t>& theVec)
  {
    SetValue (theRow, 0, theVec.x());
    SetValue (theRow, 1, theVec.y());
    SetValue (theRow, 2, theVec.z());
    SetValue (theRow, 3, theVec.w());
  }

  //! Get vector of elements for the specified column.
  //! @param theCol [in] the column to access.
  //! @return vector of elements.
  NCollection_Vec4<Element_t> GetColumn (const size_t theCol) const
  {
    return NCollection_Vec4<Element_t> (GetValue (0, theCol),
                                        GetValue (1, theCol),
                                        GetValue (2, theCol),
                                        GetValue (3, theCol));
  }

  //! Change first 3 column values by the passed vector.
  //! @param theCol [in] the column to change.
  //! @param theVec [in] the vector of values.
  void SetColumn (const size_t theCol,
                  const NCollection_Vec3<Element_t>& theVec)
  {
    SetValue (0, theCol, theVec.x());
    SetValue (1, theCol, theVec.y());
    SetValue (2, theCol, theVec.z());
  }

  //! Set column values by the passed 4 element vector.
  //! @param theCol [in] the column to change.
  //! @param theVec [in] the vector of values.
  void SetColumn (const size_t theCol,
                  const NCollection_Vec4<Element_t>& theVec)
  {
    SetValue (0, theCol, theVec.x());
    SetValue (1, theCol, theVec.y());
    SetValue (2, theCol, theVec.z());
    SetValue (3, theCol, theVec.w());
  }

  //! Get vector of diagonal elements.
  //! \return vector of diagonal elements.
  NCollection_Vec4<Element_t> GetDiagonal() const
  {
    return NCollection_Vec4<Element_t> (GetValue (0, 0),
                                        GetValue (1, 1),
                                        GetValue (2, 2),
                                        GetValue (3, 3));
  }

  //! Change first 3 elements of the diagonal matrix.
  //! @param theVec the vector of values.
  void SetDiagonal (const NCollection_Vec3<Element_t>& theVec)
  {
    SetValue (0, 0, theVec.x());
    SetValue (1, 1, theVec.y());
    SetValue (2, 2, theVec.z());
  }

  //! Set diagonal elements of the matrix by the passed vector.
  //! @param theVec [in] the vector of values.
  void SetDiagonal (const NCollection_Vec4<Element_t>& theVec)
  {
    SetValue (0, 0, theVec.x());
    SetValue (1, 1, theVec.y());
    SetValue (2, 2, theVec.z());
    SetValue (3, 3, theVec.w());
  }

  //! Initialize the identity matrix.
  void InitIdentity()
  {
    static const Element_t anIdentity[] =
      {1, 0, 0, 0,
       0, 1, 0, 0,
       0, 0, 1, 0,
       0, 0, 0, 1};

    std::memcpy (this, anIdentity, sizeof (NCollection_Mat4));
  }

  //! Raw access to the data (for OpenGL exchange).
  const Element_t* GetData()    const { return myMat; }
  Element_t*       ChangeData()       { return myMat; }
  operator const   Element_t*() const { return myMat; }
  operator         Element_t*()       { return myMat; }

  //! Multiply by the vector (M * V).
  //! @param theVec [in] the vector to multiply.
  NCollection_Vec4<Element_t> operator* (const NCollection_Vec4<Element_t>& theVec) const
  {
    return NCollection_Vec4<Element_t> (
      GetValue (0, 0) * theVec.x() + GetValue (0, 1) * theVec.y() + GetValue (0, 2) * theVec.z() + GetValue (0, 3) * theVec.w(),
      GetValue (1, 0) * theVec.x() + GetValue (1, 1) * theVec.y() + GetValue (1, 2) * theVec.z() + GetValue (1, 3) * theVec.w(),
      GetValue (2, 0) * theVec.x() + GetValue (2, 1) * theVec.y() + GetValue (2, 2) * theVec.z() + GetValue (2, 3) * theVec.w(),
      GetValue (3, 0) * theVec.x() + GetValue (3, 1) * theVec.y() + GetValue (3, 2) * theVec.z() + GetValue (3, 3) * theVec.w());
  }

  //! Compute matrix multiplication product: A * B.
  //! @param theMatA [in] the matrix "A".
  //! @param theMatB [in] the matrix "B".
  NCollection_Mat4 Multiply (const NCollection_Mat4& theMatA,
                             const NCollection_Mat4& theMatB)
  {
    NCollection_Mat4 aMatRes;

    size_t aInputElem;
    for (size_t aResElem = 0; aResElem < 16; ++aResElem)
    {
      aMatRes[aResElem] = (Element_t )0;
      for (aInputElem = 0; aInputElem < 4; ++aInputElem)
      {
        aMatRes[aResElem] += theMatA.GetValue(aResElem % 4, aInputElem)
                           * theMatB.GetValue(aInputElem, aResElem / 4);
      }
    }

    return aMatRes;
  }

  //! Compute matrix multiplication.
  //! @param theMat [in] the matrix to multiply.
  void Multiply (const NCollection_Mat4& theMat)
  {
    *this = Multiply(*this, theMat);
  }

  //! Multiply by the another matrix.
  //! @param theMat [in] the other matrix.
  NCollection_Mat4& operator*= (const NCollection_Mat4& theMat)
  {
    Multiply (theMat);
    return *this;
  }

  //! Compute matrix multiplication product.
  //! @param theMat [in] the other matrix.
  //! @return result of multiplication.
  NCollection_Mat4 operator* (const NCollection_Mat4& theMat) const
  {
    return Multiplied (theMat);
  }

  //! Compute matrix multiplication product.
  //! @param theMat [in] the other matrix.
  //! @return result of multiplication.
  NCollection_Mat4 Multiplied (const NCollection_Mat4& theMat) const
  {
    NCollection_Mat4 aTempMat (*this);
    aTempMat *= theMat;
    return aTempMat;
  }

  //! Compute per-component multiplication.
  //! @param theFactor [in] the scale factor.
  void Multiply (const Element_t theFactor)
  {
    for (size_t i = 0; i < 16; ++i)
    {
      myMat[i] *= theFactor;
    }
  }

  //! Compute per-element multiplication.
  //! @param theFactor [in] the scale factor.
  NCollection_Mat4& operator*=(const Element_t theFactor)
  {
    Multiply (theFactor);
    return *this;
  }

  //! Compute per-element multiplication.
  //! @param theFactor [in] the scale factor.
  //! @return the result of multiplicaton.
  NCollection_Mat4 operator* (const Element_t theFactor) const
  {
    return Multiplied (theFactor);
  }

  //! Compute per-element multiplication.
  //! @param theFactor [in] the scale factor.
  //! @return the result of multiplicaton.
  NCollection_Mat4 Multiplied (const Element_t theFactor) const
  {
    NCollection_Mat4 aTempMat (*this);
    aTempMat *= theFactor;
    return aTempMat;
  }

  //! Translate the matrix on the passed vector.
  //! @param theVec [in] the translation vector.
  void Translate (const NCollection_Vec3<Element_t>& theVec)
  {
    NCollection_Mat4 aTempMat;
    aTempMat.SetColumn (3, theVec);
    this->Multiply (aTempMat);
  }

  //! Transpose the matrix.
  //! @return transposed copy of the matrix.
  NCollection_Mat4 Transposed() const
  {
    NCollection_Mat4 aTempMat;
    aTempMat.SetRow (0, GetColumn (0));
    aTempMat.SetRow (1, GetColumn (1));
    aTempMat.SetRow (2, GetColumn (2));
    aTempMat.SetRow (3, GetColumn (3));
    return aTempMat;
  }

  //! Transpose the matrix.
  void Transpose()
  {
    *this = Transposed();
  }

  //! Compute inverted matrix.
  //! @param theOutMx [out] the inverted matrix.
  //! @return true if reversion success.
  bool Inverted (NCollection_Mat4<Element_t>& theOutMx) const
  {
    Element_t* inv = theOutMx.myMat;

    // use short-cut for better readability
    const Element_t* m = myMat;

    inv[ 0] = m[ 5] * (m[10] * m[15] - m[11] * m[14]) -
              m[ 9] * (m[ 6] * m[15] - m[ 7] * m[14]) -
              m[13] * (m[ 7] * m[10] - m[ 6] * m[11]);

    inv[ 1] = m[ 1] * (m[11] * m[14] - m[10] * m[15]) -
              m[ 9] * (m[ 3] * m[14] - m[ 2] * m[15]) -
              m[13] * (m[ 2] * m[11] - m[ 3] * m[10]);

    inv[ 2] = m[ 1] * (m[ 6] * m[15] - m[ 7] * m[14]) -
              m[ 5] * (m[ 2] * m[15] - m[ 3] * m[14]) -
              m[13] * (m[ 3] * m[ 6] - m[ 2] * m[ 7]);

    inv[ 3] = m[ 1] * (m[ 7] * m[10] - m[ 6] * m[11]) -
              m[ 5] * (m[ 3] * m[10] - m[ 2] * m[11]) -
              m[ 9] * (m[ 2] * m[ 7] - m[ 3] * m[ 6]);

    inv[ 4] = m[ 4] * (m[11] * m[14] - m[10] * m[15]) -
              m[ 8] * (m[ 7] * m[14] - m[ 6] * m[15]) -
              m[12] * (m[ 6] * m[11] - m[ 7] * m[10]);

    inv[ 5] = m[ 0] * (m[10] * m[15] - m[11] * m[14]) -
              m[ 8] * (m[ 2] * m[15] - m[ 3] * m[14]) -
              m[12] * (m[ 3] * m[10] - m[ 2] * m[11]);

    inv[ 6] = m[ 0] * (m[ 7] * m[14] - m[ 6] * m[15]) -
              m[ 4] * (m[ 3] * m[14] - m[ 2] * m[15]) -
              m[12] * (m[ 2] * m[ 7] - m[ 3] * m[ 6]);

    inv[ 7] = m[ 0] * (m[ 6] * m[11] - m[ 7] * m[10]) -
              m[ 4] * (m[ 2] * m[11] - m[ 3] * m[10]) -
              m[ 8] * (m[ 3] * m[ 6] - m[ 2] * m[ 7]);

    inv[ 8] = m[ 4] * (m[ 9] * m[15] - m[11] * m[13]) -
              m[ 8] * (m[ 5] * m[15] - m[ 7] * m[13]) -
              m[12] * (m[ 7] * m[ 9] - m[ 5] * m[11]);

    inv[ 9] = m[ 0] * (m[11] * m[13] - m[ 9] * m[15]) -
              m[ 8] * (m[ 3] * m[13] - m[ 1] * m[15]) -
              m[12] * (m[ 1] * m[11] - m[ 3] * m[ 9]);

    inv[10] = m[ 0] * (m[ 5] * m[15] - m[ 7] * m[13]) -
              m[ 4] * (m[ 1] * m[15] - m[ 3] * m[13]) -
              m[12] * (m[ 3] * m[ 5] - m[ 1] * m[ 7]);

    inv[11] = m[ 0] * (m[ 7] * m[ 9] - m[ 5] * m[11]) -
              m[ 4] * (m[ 3] * m[ 9] - m[ 1] * m[11]) -
              m[ 8] * (m[ 1] * m[ 7] - m[ 3] * m[ 5]);

    inv[12] = m[ 4] * (m[10] * m[13] - m[ 9] * m[14]) -
              m[ 8] * (m[ 6] * m[13] - m[ 5] * m[14]) -
              m[12] * (m[ 5] * m[10] - m[ 6] * m[ 9]);

    inv[13] = m[ 0] * (m[ 9] * m[14] - m[10] * m[13]) -
              m[ 8] * (m[ 1] * m[14] - m[ 2] * m[13]) -
              m[12] * (m[ 2] * m[ 9] - m[ 1] * m[10]);

    inv[14] = m[ 0] * (m[ 6] * m[13] - m[ 5] * m[14]) -
              m[ 4] * (m[ 2] * m[13] - m[ 1] * m[14]) -
              m[12] * (m[ 1] * m[ 6] - m[ 2] * m[ 5]);

    inv[15] = m[ 0] * (m[ 5] * m[10] - m[ 6] * m[ 9]) -
              m[ 4] * (m[ 1] * m[10] - m[ 2] * m[ 9]) -
              m[ 8] * (m[ 2] * m[ 5] - m[ 1] * m[ 6]);

    Element_t aDet = m[0] * inv[ 0] +
                     m[1] * inv[ 4] +
                     m[2] * inv[ 8] +
                     m[3] * inv[12];

    if (aDet == 0)
      return false;

    aDet = (Element_t) 1. / aDet;

    for (int i = 0; i < 16; ++i)
      inv[i] *= aDet;

    return true;
  }

private:

  Element_t myMat[16];

};

#endif // _NCollection_Mat4_HeaderFile
Commit	Line	Data
30f0ad28	1	// Created on: 2013-05-30
	2	// Created by: Anton POLETAEV
	3	// Copyright (c) 2013 OPEN CASCADE SAS
	4	//
973c2be1	5	// This file is part of Open CASCADE Technology software library.
30f0ad28	6	//
973c2be1	7	// This library is free software; you can redistribute it and / or modify it
	8	// under the terms of the GNU Lesser General Public version 2.1 as published
	9	// by the Free Software Foundation, with special exception defined in the file
	10	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	11	// distribution for complete text of the license and disclaimer of any warranty.
30f0ad28	12	//
973c2be1	13	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	14	// commercial license or contractual agreement.
30f0ad28	15
	16	#ifndef _NCollection_Mat4_HeaderFile
	17	#define _NCollection_Mat4_HeaderFile
	18
	19	#include <NCollection_Vec4.hxx>
	20
	21	//! Generic matrix of 4 x 4 elements.
	22	//! To be used in conjunction with NCollection_Vec4 entities.
	23	//! Originally introduced for 3D space projection and orientation
	24	//! operations.
	25	template<typename Element_t>
	26	class NCollection_Mat4
	27	{
	28
	29	public:
	30
	31	//! Get number of rows.
	32	//! @return number of rows.
	33	static size_t Rows()
	34	{
	35	return 4;
	36	}
	37
	38	//! Get number of columns.
	39	//! @retur number of columns.
	40	static size_t Cols()
	41	{
	42	return 4;
	43	}
	44
	45	//! Empty constructor.
	46	//! Construct the zero matrix.
	47	NCollection_Mat4()
	48	{
	49	InitIdentity();
	50	}
	51
	52	//! Copy constructor.
	53	//! @param theOther [in] the matrix to copy values from.
	54	NCollection_Mat4 (const NCollection_Mat4& theOther)
	55	{
	56	std::memcpy (this, &theOther, sizeof (NCollection_Mat4));
	57	}
	58
	59	//! Assignment operator.
	60	//! @param theOther [in] the matrix to copy values from.
	61	const NCollection_Mat4& operator= (const NCollection_Mat4& theOther)
	62	{
	63	std::memcpy (this, &theOther, sizeof (NCollection_Mat4));
	64	return *this;
	65	}
	66
	67	//! Get element at the specified row and column.
	68	//! @param theRow [in] the row.to address.
	69	//! @param theCol [in] the column to address.
	70	//! @return the value of the addressed element.
	71	Element_t GetValue (const size_t theRow, const size_t theCol) const
	72	{
	73	return myMat[theCol * 4 + theRow];
	74	}
	75
	76	//! Access element at the specified row and column.
	77	//! @param theRow [in] the row.to access.
	78	//! @param theCol [in] the column to access.
79	//! @return reference on the matrix element.
80	Element_t& ChangeValue (const size_t theRow, const size_t theCol)
81	{
82	return myMat[theCol * 4 + theRow];
83	}
84
85	//! Set value for the element specified by row and columns.
86	//! @param theRow [in] the row to change.
87	//! @param theCol [in] the column to change.
88	//! @param theValue [in] the value to set.s
89	void SetValue (const size_t theRow,
90	const size_t theCol,
91	const Element_t theValue)
92	{
93	myMat[theCol * 4 + theRow] = theValue;
94	}
95
96	//! Get vector of elements for the specified row.
97	//! @param theRow [in] the row to access.
98	//! @return vector of elements.
99	NCollection_Vec4<Element_t> GetRow (const size_t theRow) const
100	{
101	return NCollection_Vec4<Element_t> (GetValue (theRow, 0),
102	GetValue (theRow, 1),
103	GetValue (theRow, 2),
104	GetValue (theRow, 3));
105	}
106
107	//! Change first 3 row values by the passed vector.
108	//! @param theRow [in] the row to change.
109	//! @param theVec [in] the vector of values.
110	void SetRow (const size_t theRow, const NCollection_Vec3<Element_t>& theVec)
111	{
112	SetValue (theRow, 0, theVec.x());
113	SetValue (theRow, 1, theVec.y());
114	SetValue (theRow, 2, theVec.z());
115	}
116
117	//! Set row values by the passed 4 element vector.
118	//! @param theRow [in] the row to change.
119	//! @param theVec [in] the vector of values.
120	void SetRow (const size_t theRow, const NCollection_Vec4<Element_t>& theVec)
121	{
122	SetValue (theRow, 0, theVec.x());
123	SetValue (theRow, 1, theVec.y());
124	SetValue (theRow, 2, theVec.z());
125	SetValue (theRow, 3, theVec.w());
126	}
127
128	//! Get vector of elements for the specified column.
129	//! @param theCol [in] the column to access.
130	//! @return vector of elements.
131	NCollection_Vec4<Element_t> GetColumn (const size_t theCol) const
132	{
133	return NCollection_Vec4<Element_t> (GetValue (0, theCol),
134	GetValue (1, theCol),
135	GetValue (2, theCol),
136	GetValue (3, theCol));
137	}
138
139	//! Change first 3 column values by the passed vector.
140	//! @param theCol [in] the column to change.
141	//! @param theVec [in] the vector of values.
142	void SetColumn (const size_t theCol,
143	const NCollection_Vec3<Element_t>& theVec)
144	{
145	SetValue (0, theCol, theVec.x());
146	SetValue (1, theCol, theVec.y());
147	SetValue (2, theCol, theVec.z());
148	}
149
150	//! Set column values by the passed 4 element vector.
151	//! @param theCol [in] the column to change.
152	//! @param theVec [in] the vector of values.
153	void SetColumn (const size_t theCol,
154	const NCollection_Vec4<Element_t>& theVec)
155	{
156	SetValue (0, theCol, theVec.x());
157	SetValue (1, theCol, theVec.y());
158	SetValue (2, theCol, theVec.z());
159	SetValue (3, theCol, theVec.w());
160	}
161
162	//! Get vector of diagonal elements.
163	//! \return vector of diagonal elements.
164	NCollection_Vec4<Element_t> GetDiagonal() const
165	{
166	return NCollection_Vec4<Element_t> (GetValue (0, 0),
167	GetValue (1, 1),
168	GetValue (2, 2),
169	GetValue (3, 3));
170	}
171
172	//! Change first 3 elements of the diagonal matrix.
173	//! @param theVec the vector of values.
174	void SetDiagonal (const NCollection_Vec3<Element_t>& theVec)
175	{
176	SetValue (0, 0, theVec.x());
177	SetValue (1, 1, theVec.y());
178	SetValue (2, 2, theVec.z());
179	}
180
181	//! Set diagonal elements of the matrix by the passed vector.
182	//! @param theVec [in] the vector of values.
183	void SetDiagonal (const NCollection_Vec4<Element_t>& theVec)
184	{
185	SetValue (0, 0, theVec.x());
186	SetValue (1, 1, theVec.y());
187	SetValue (2, 2, theVec.z());
188	SetValue (3, 3, theVec.w());
189	}
190
191	//! Initialize the identity matrix.
192	void InitIdentity()
193	{
194	static const Element_t anIdentity[] =
195	{1, 0, 0, 0,
196	0, 1, 0, 0,
197	0, 0, 1, 0,
198	0, 0, 0, 1};
199
200	std::memcpy (this, anIdentity, sizeof (NCollection_Mat4));
201	}
202
203	//! Raw access to the data (for OpenGL exchange).
938d4544	204	const Element_t* GetData() const { return myMat; }
	205	Element_t* ChangeData() { return myMat; }
	206	operator const Element_t*() const { return myMat; }
	207	operator Element_t*() { return myMat; }
30f0ad28	208
	209	//! Multiply by the vector (M * V).
	210	//! @param theVec [in] the vector to multiply.
	211	NCollection_Vec4<Element_t> operator* (const NCollection_Vec4<Element_t>& theVec) const
	212	{
	213	return NCollection_Vec4<Element_t> (
	214	GetValue (0, 0) * theVec.x() + GetValue (0, 1) * theVec.y() + GetValue (0, 2) * theVec.z() + GetValue (0, 3) * theVec.w(),
	215	GetValue (1, 0) * theVec.x() + GetValue (1, 1) * theVec.y() + GetValue (1, 2) * theVec.z() + GetValue (1, 3) * theVec.w(),
	216	GetValue (2, 0) * theVec.x() + GetValue (2, 1) * theVec.y() + GetValue (2, 2) * theVec.z() + GetValue (2, 3) * theVec.w(),
	217	GetValue (3, 0) * theVec.x() + GetValue (3, 1) * theVec.y() + GetValue (3, 2) * theVec.z() + GetValue (3, 3) * theVec.w());
	218	}
	219
	220	//! Compute matrix multiplication product: A * B.
	221	//! @param theMatA [in] the matrix "A".
	222	//! @param theMatB [in] the matrix "B".
	223	NCollection_Mat4 Multiply (const NCollection_Mat4& theMatA,
	224	const NCollection_Mat4& theMatB)
	225	{
	226	NCollection_Mat4 aMatRes;
	227
	228	size_t aInputElem;
	229	for (size_t aResElem = 0; aResElem < 16; ++aResElem)
	230	{
	231	aMatRes[aResElem] = (Element_t )0;
	232	for (aInputElem = 0; aInputElem < 4; ++aInputElem)
	233	{
	234	aMatRes[aResElem] += theMatA.GetValue(aResElem % 4, aInputElem)
	235	* theMatB.GetValue(aInputElem, aResElem / 4);
	236	}
	237	}
	238
	239	return aMatRes;
	240	}
	241
	242	//! Compute matrix multiplication.
	243	//! @param theMat [in] the matrix to multiply.
	244	void Multiply (const NCollection_Mat4& theMat)
	245	{
	246	this = Multiply(this, theMat);
	247	}
	248
	249	//! Multiply by the another matrix.
	250	//! @param theMat [in] the other matrix.
	251	NCollection_Mat4& operator*= (const NCollection_Mat4& theMat)
	252	{
	253	Multiply (theMat);
	254	return *this;
	255	}
	256
	257	//! Compute matrix multiplication product.
	258	//! @param theMat [in] the other matrix.
	259	//! @return result of multiplication.
	260	NCollection_Mat4 operator* (const NCollection_Mat4& theMat) const
	261	{
938d4544	262	return Multiplied (theMat);
30f0ad28	263	}
	264
	265	//! Compute matrix multiplication product.
	266	//! @param theMat [in] the other matrix.
	267	//! @return result of multiplication.
	268	NCollection_Mat4 Multiplied (const NCollection_Mat4& theMat) const
	269	{
	270	NCollection_Mat4 aTempMat (*this);
	271	aTempMat *= theMat;
	272	return aTempMat;
	273	}
	274
	275	//! Compute per-component multiplication.
	276	//! @param theFactor [in] the scale factor.
	277	void Multiply (const Element_t theFactor)
	278	{
	279	for (size_t i = 0; i < 16; ++i)
	280	{
	281	myMat[i] *= theFactor;
	282	}
	283	}
	284
	285	//! Compute per-element multiplication.
	286	//! @param theFactor [in] the scale factor.
	287	NCollection_Mat4& operator*=(const Element_t theFactor)
	288	{
	289	Multiply (theFactor);
	290	return *this;
	291	}
	292
	293	//! Compute per-element multiplication.
	294	//! @param theFactor [in] the scale factor.
	295	//! @return the result of multiplicaton.
	296	NCollection_Mat4 operator* (const Element_t theFactor) const
	297	{
	298	return Multiplied (theFactor);
	299	}
	300
	301	//! Compute per-element multiplication.
	302	//! @param theFactor [in] the scale factor.
	303	//! @return the result of multiplicaton.
	304	NCollection_Mat4 Multiplied (const Element_t theFactor) const
	305	{
	306	NCollection_Mat4 aTempMat (*this);
	307	aTempMat *= theFactor;
	308	return aTempMat;
	309	}
	310
	311	//! Translate the matrix on the passed vector.
	312	//! @param theVec [in] the translation vector.
	313	void Translate (const NCollection_Vec3<Element_t>& theVec)
	314	{
	315	NCollection_Mat4 aTempMat;
	316	aTempMat.SetColumn (3, theVec);
	317	this->Multiply (aTempMat);
	318	}
	319
938d4544	320	//! Transpose the matrix.
	321	//! @return transposed copy of the matrix.
	322	NCollection_Mat4 Transposed() const
	323	{
	324	NCollection_Mat4 aTempMat;
	325	aTempMat.SetRow (0, GetColumn (0));
	326	aTempMat.SetRow (1, GetColumn (1));
	327	aTempMat.SetRow (2, GetColumn (2));
	328	aTempMat.SetRow (3, GetColumn (3));
	329	return aTempMat;
	330	}
	331
	332	//! Transpose the matrix.
	333	void Transpose()
	334	{
	335	*this = Transposed();
	336	}
	337
30f0ad28	338	//! Compute inverted matrix.
	339	//! @param theOutMx [out] the inverted matrix.
	340	//! @return true if reversion success.
	341	bool Inverted (NCollection_Mat4<Element_t>& theOutMx) const
	342	{
	343	Element_t* inv = theOutMx.myMat;
	344
	345	// use short-cut for better readability
	346	const Element_t* m = myMat;
	347
	348	inv[ 0] = m[ 5] * (m[10] * m[15] - m[11] * m[14]) -
	349	m[ 9] * (m[ 6] * m[15] - m[ 7] * m[14]) -
	350	m[13] * (m[ 7] * m[10] - m[ 6] * m[11]);
	351
	352	inv[ 1] = m[ 1] * (m[11] * m[14] - m[10] * m[15]) -
	353	m[ 9] * (m[ 3] * m[14] - m[ 2] * m[15]) -
	354	m[13] * (m[ 2] * m[11] - m[ 3] * m[10]);
	355
	356	inv[ 2] = m[ 1] * (m[ 6] * m[15] - m[ 7] * m[14]) -
	357	m[ 5] * (m[ 2] * m[15] - m[ 3] * m[14]) -
	358	m[13] * (m[ 3] * m[ 6] - m[ 2] * m[ 7]);
	359
	360	inv[ 3] = m[ 1] * (m[ 7] * m[10] - m[ 6] * m[11]) -
	361	m[ 5] * (m[ 3] * m[10] - m[ 2] * m[11]) -
	362	m[ 9] * (m[ 2] * m[ 7] - m[ 3] * m[ 6]);
	363
	364	inv[ 4] = m[ 4] * (m[11] * m[14] - m[10] * m[15]) -
	365	m[ 8] * (m[ 7] * m[14] - m[ 6] * m[15]) -
	366	m[12] * (m[ 6] * m[11] - m[ 7] * m[10]);
	367
	368	inv[ 5] = m[ 0] * (m[10] * m[15] - m[11] * m[14]) -
	369	m[ 8] * (m[ 2] * m[15] - m[ 3] * m[14]) -
	370	m[12] * (m[ 3] * m[10] - m[ 2] * m[11]);
	371
	372	inv[ 6] = m[ 0] * (m[ 7] * m[14] - m[ 6] * m[15]) -
	373	m[ 4] * (m[ 3] * m[14] - m[ 2] * m[15]) -
	374	m[12] * (m[ 2] * m[ 7] - m[ 3] * m[ 6]);
	375
	376	inv[ 7] = m[ 0] * (m[ 6] * m[11] - m[ 7] * m[10]) -
	377	m[ 4] * (m[ 2] * m[11] - m[ 3] * m[10]) -
	378	m[ 8] * (m[ 3] * m[ 6] - m[ 2] * m[ 7]);
	379
	380	inv[ 8] = m[ 4] * (m[ 9] * m[15] - m[11] * m[13]) -
	381	m[ 8] * (m[ 5] * m[15] - m[ 7] * m[13]) -
	382	m[12] * (m[ 7] * m[ 9] - m[ 5] * m[11]);
	383
	384	inv[ 9] = m[ 0] * (m[11] * m[13] - m[ 9] * m[15]) -
	385	m[ 8] * (m[ 3] * m[13] - m[ 1] * m[15]) -
	386	m[12] * (m[ 1] * m[11] - m[ 3] * m[ 9]);
	387
	388	inv[10] = m[ 0] * (m[ 5] * m[15] - m[ 7] * m[13]) -
	389	m[ 4] * (m[ 1] * m[15] - m[ 3] * m[13]) -
	390	m[12] * (m[ 3] * m[ 5] - m[ 1] * m[ 7]);
	391
	392	inv[11] = m[ 0] * (m[ 7] * m[ 9] - m[ 5] * m[11]) -
	393	m[ 4] * (m[ 3] * m[ 9] - m[ 1] * m[11]) -
	394	m[ 8] * (m[ 1] * m[ 7] - m[ 3] * m[ 5]);
	395
	396	inv[12] = m[ 4] * (m[10] * m[13] - m[ 9] * m[14]) -
	397	m[ 8] * (m[ 6] * m[13] - m[ 5] * m[14]) -
	398	m[12] * (m[ 5] * m[10] - m[ 6] * m[ 9]);
	399
	400	inv[13] = m[ 0] * (m[ 9] * m[14] - m[10] * m[13]) -
	401	m[ 8] * (m[ 1] * m[14] - m[ 2] * m[13]) -
402	m[12] * (m[ 2] * m[ 9] - m[ 1] * m[10]);
403
404	inv[14] = m[ 0] * (m[ 6] * m[13] - m[ 5] * m[14]) -
405	m[ 4] * (m[ 2] * m[13] - m[ 1] * m[14]) -
406	m[12] * (m[ 1] * m[ 6] - m[ 2] * m[ 5]);
407
408	inv[15] = m[ 0] * (m[ 5] * m[10] - m[ 6] * m[ 9]) -
409	m[ 4] * (m[ 1] * m[10] - m[ 2] * m[ 9]) -
410	m[ 8] * (m[ 2] * m[ 5] - m[ 1] * m[ 6]);
411
412	Element_t aDet = m[0] * inv[ 0] +
413	m[1] * inv[ 4] +
414	m[2] * inv[ 8] +
415	m[3] * inv[12];
416
417	if (aDet == 0)
418	return false;
419
420	aDet = (Element_t) 1. / aDet;
421
422	for (int i = 0; i < 16; ++i)
423	inv[i] *= aDet;
424
425	return true;
426	}
427
428	private:
429
430	Element_t myMat[16];
431
432	};
433
938d4544	434	#endif // _NCollection_Mat4_HeaderFile