MeVis/Foundation/Sources/MLLinearAlgebra/mlVector4.h

Go to the documentation of this file.

// **InsertLicense** code 
//=====================================================================================

//=====================================================================================

#ifndef __mlVector4_H
#define __mlVector4_H

// Include system independency file and project settings.
#ifndef __mlLinearAlgebraSystem_H
#include "mlLinearAlgebraSystem.h"
#endif
#ifndef __mlLinearAlgebraDefs_H
#include "mlLinearAlgebraDefs.h"
#endif
#ifndef __mlFloatingPointVector_H
#include "mlFloatingPointVector.h"
#endif
#ifndef __mlVector2_H
#include "mlVector2.h"
#endif
#ifndef __mlVector3_H
#include "mlVector3.h"
#endif
#ifndef __mlMatrix3_H
#include "mlMatrix3.h"
#endif
#ifndef __mlMatrix4_H
#include "mlMatrix4.h"
#endif

// All declarations of this header will be in the ML_LA_NAMESPACE namespace.
ML_LA_START_NAMESPACE

//--------------------------------------------------------------------
// This is necessary because we do not known whether vector or 
// matrix header is included first and we cannot move template
// code into C++ file.
//--------------------------------------------------------------------
template <class DT> class Tvec2;
template <class DT> class Tvec3;
template <class DT> class Tmat3;
template <class DT> class Tmat4;

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
class Tvec4 : public FloatingPointVector<DT,4> {
public:
  
  typedef FloatingPointVector<DT,4> Superclass;

  typedef DT ComponentType;
  
  //--------------------------------------------------------------------

  //--------------------------------------------------------------------
  inline explicit Tvec4(const DT value=0) : Superclass(value)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec4::Tvec4(const DT value=0)");
  }
  
  inline Tvec4(const Superclass &v): Superclass(v)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec4::Tvec4(const FloatingPointVector<DT,4>& v)");
  }
  
  inline Tvec4(const DT x, const DT y, const DT z, const DT w)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec4::Tvec4(const DT x, const DT y, const DT z, const DT w)");
    
    Superclass::_buffer[0] = x;  
    Superclass::_buffer[1] = y;  
    Superclass::_buffer[2] = z;  
    Superclass::_buffer[3] = w;
  }
  
  inline Tvec4(const Tvec2<DT>& v, const DT z, const DT w)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec4::Tvec4(const Tvec2<DT>& v, const DT z, const DT w)");
    
    Superclass::_buffer[0] = v[0];  
    Superclass::_buffer[1] = v[1];  
    Superclass::_buffer[2] = z;  
    Superclass::_buffer[3] = w;
  }
  
  inline Tvec4(const Tvec3<DT>& v, const DT w)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec4::Tvec4(const Tvec3<DT>& v, const DT w)");
    
    Superclass::_buffer[0] = v[0];  
    Superclass::_buffer[1] = v[1];
    Superclass::_buffer[2] = v[2];  
    Superclass::_buffer[3] = w;
  }
  
  inline void assign(const DT x, const DT y, const DT z, const DT c)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec4::assign(const DT x, const DT y, const DT z, const DT c)");
    
    Superclass::_buffer[0] = x;
    Superclass::_buffer[1] = y;
    Superclass::_buffer[2] = z;
    Superclass::_buffer[3] = c;
  }
  
  inline Tvec4<DT> divideByLastComp() const
  {
    ML_TRACE_IN( "divideByLastComp() const( )" );
    
    Tvec4<DT> retVal;
    ML_TRY
    {
      const DT lastComp = Superclass::_buffer[3];
      
      ML_CHECK_FLOAT_THROW(lastComp);
      const DT div = static_cast<DT>(1) / lastComp;
      retVal = Tvec4<DT>(Superclass::_buffer[0] * div, 
                         Superclass::_buffer[1] * div, 
                         Superclass::_buffer[2] * div, 1);
    }
    ML_CATCH_RETHROW;
    return retVal;
  }
};

#define _ML_VEC4_RC(i) a[i][0]*v[0] + a[i][1]*v[1] + a[i][2]*v[2] + a[i][3]*v[3]
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class DT>
inline Tvec4<DT> operator*(const Tmat4<DT>& a, const Tvec4<DT>& v)
{
  ML_TRACE_IN_TIME_CRITICAL("mlVector4.h: operator*(const Tmat4<DT>& a, const Tvec4<DT>& v)");
  
  return Tvec4<DT>(_ML_VEC4_RC(0), _ML_VEC4_RC(1), _ML_VEC4_RC(2), _ML_VEC4_RC(3));
}
#undef _ML_VEC4_RC

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class DT>
inline Tvec4<DT> operator*(const Tvec4<DT>& v, const Tmat4<DT>& a)
{
  ML_TRACE_IN_TIME_CRITICAL("mlVector4.h: operator*(const Tvec4<DT>& v, const Tmat4<DT>& a)");
  
  return a.transpose() * v;
}


//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------
typedef Tvec4<MLfloat>   Vector4f;
typedef Tvec4<MLdouble>  Vector4d;
typedef Tvec4<MLldouble> Vector4ld;
typedef Tvec4<MLdouble>  Vector4;


#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Tvec4<MLfloat>   vecf4;
ML_DEPRECATED typedef Tvec4<MLdouble>  vecd4;
ML_DEPRECATED typedef Tvec4<MLldouble> vecld4;
ML_DEPRECATED typedef Tvec4<MLdouble> vec4;

#endif // ML_DEPRECATED


ML_LA_END_NAMESPACE

#endif //of __mlVector4_H