TeslaRel410/CODE/RP/MUNGA/LINMTRX.HPP

//===========================================================================//
// File:	linmtrx.hh                                                          //
// Project: MUNGA           Brick: Math Library                              //
// Contents: Interface specification for the linear matrices                 //
//---------------------------------------------------------------------------//
//   Date    Who  Modification                                               //
// --------  ---  ---------------------------------------------------------- //
// 11/20/94  JMA  Initial coding.                                            //
// 12/01/94  JMA  Made compatible with SGI CC                                //
//---------------------------------------------------------------------------//
// Copyright (C) 1994-1995, Virtual World Entertainment, Inc.                //
// All Rights reserved worldwide                                             //
// This unpublished sourcecode is PROPRIETARY and CONFIDENTIAL               //
//===========================================================================//

#if !defined(LINMTRX_HPP)
#	define LINMTRX_HPP

#	if !defined(AFFNMTRX_HPP)
#		include <affnmtrx.hpp>
#	endif

#	if !defined(UNITVEC_HPP)
#		include <unitvec.hpp>
#	endif

#	if !defined(ROTATION_HPP)
#		include <rotation.hpp>
#	endif

	//~~~~~~~~~~~~~~~~~~~~~~~~~~ LinearMatrix ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	class LinearMatrix:
		public AffineMatrix
	{
	public:
		static const LinearMatrix
			Identity;

		//
		// Constructors
		//
		LinearMatrix()
			{BuildIdentity(); }// JM 11-25-95
		LinearMatrix(int)
			{BuildIdentity();}

		//
		// Assignment Operators
		//
		LinearMatrix&
			operator=(const LinearMatrix &m)
				{AffineMatrix::operator=(m); return *this;}
		LinearMatrix&
			operator=(const Origin &p)
				{AffineMatrix::operator=(p); return *this;}
		LinearMatrix&
			operator=(const Hinge &hinge)
				{AffineMatrix::operator=(hinge); return *this;}
		LinearMatrix&
			operator=(const EulerAngles &angles)
				{AffineMatrix::operator=(angles); return *this;}
		LinearMatrix&
			operator=(const YawPitchRoll &angles)
				{AffineMatrix::operator=(angles); return *this;}
		LinearMatrix&
			operator=(const Quaternion &q)
				{AffineMatrix::operator=(q); return *this;}
		LinearMatrix&
			operator=(const Point3D &p)
				{AffineMatrix::operator=(p); return *this;}
		LinearMatrix&
			operator=(const AffineMatrix &m);
		LinearMatrix&
			operator=(const Matrix4x4 &m);
		LinearMatrix&
			operator=(const TransposedMatrix &m);

		//
		// Axis Manipulation
		//
		void
			GetFromAxis(size_t index, UnitVector *v) const
				{AffineMatrix::GetFromAxis(index,v);}
		void
			GetToAxis(size_t index, UnitVector *v) const
				{AffineMatrix::GetToAxis(index,v);}

		LinearMatrix&
			SetFromAxis(size_t index, const UnitVector &v)
				{AffineMatrix::SetFromAxis(index,v); return *this;}
		LinearMatrix&
			SetToAxis(size_t index, const UnitVector &v)
				{AffineMatrix::SetToAxis(index,v); return *this;}

		//
		// Matrix4x4 Multiplication
		//
		LinearMatrix&
			Multiply(
				const LinearMatrix& m1,
				const LinearMatrix& m2
			)
				{AffineMatrix::Multiply(m1, m2); return *this;}
		LinearMatrix&
			operator *=(const LinearMatrix& M)
				{LinearMatrix src(*this); return Multiply(src, M);}

		//
		// Matrix4x4 Inversion
		//
		LinearMatrix&
			Invert(const LinearMatrix& Source);
		LinearMatrix&
			Invert()
				{LinearMatrix src(*this); return Invert(src);}

		//
		// Rotation and Translation
		//
		LinearMatrix&
			Multiply(const LinearMatrix &m,const Quaternion &q)
				{
					Check_Pointer(this); Check(&m); Check(&q);
					AffineMatrix::Multiply(m,q); return *this;
				}
		LinearMatrix&
			operator*=(const Quaternion &q)
				{Check(this); LinearMatrix m(*this); return Multiply(m,q);}
		LinearMatrix&
			Multiply(const LinearMatrix &m,const Point3D &p)
				{
					Check_Pointer(this); Check(&m); Check(&p);
					AffineMatrix::Multiply(m,p); return *this;
				}
		LinearMatrix&
			operator*=(const Point3D& p)
				{Check(this); LinearMatrix m(*this); return Multiply(m,p);}

		//
		// Support functions
		//
		LinearMatrix&
			Normalize();

		Logical
      	TestInstance() const;
		static Logical
			TestClass();

	private:
		LinearMatrix& Solve();
	};

	inline UnitVector&
		UnitVector::Multiply(
			const UnitVector &v,
			const LinearMatrix &m
		)
			{Check(&v); Vector3D::Multiply(v,m); return *this;}

	inline UnitVector&
		UnitVector::operator*=(const LinearMatrix &m)
			{UnitVector src(*this); return Multiply(src,m);}

	inline Quaternion&
		Quaternion::Multiply(
			const Quaternion &q,
			const LinearMatrix &m
		)
			{
				Cast_Object(Vector3D*,this)->Multiply(SKIPPY_CAST(Vector3D,q),m);
				return *this;
			}

	inline Quaternion&
		Quaternion::operator*=(const LinearMatrix &m)
			{Quaternion t(*this); return Multiply(t,m);}


#endif