AffineMatrix4x4.h

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material without having a written signed agreement with Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
#ifndef MOMENTUM_AFFINEMATRIX4X4_H
#define MOMENTUM_AFFINEMATRIX4X4_H
 
#include <momentum_namespace.h>
#include <momentum_export.h>
 
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4714) // Disable warnings about not able to force inline
#endif
 
#include "Matrix4x4.h"
#include <agx/AffineMatrix4x4.h>
 
namespace MOMENTUM_NAMESPACE
{
  class EulerAngles;
 
#define MOMENTUM_AFFINEMATRIX4X4_SET_ROW(row, v1, v2, v3 )    \
  this->m_data[(row)][0] = (v1); \
  this->m_data[(row)][1] = (v2); \
  this->m_data[(row)][2] = (v3);
 
#define MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(a,b,r,c) \
   ((a).m_data[r][0] * (b).m_data[0][c]) \
  +((a).m_data[r][1] * (b).m_data[1][c]) \
  +((a).m_data[r][2] * (b).m_data[2][c])
 
  class MOMENTUM_EXPORT AffineMatrix4x4 : public Matrix4x4
  {
    public:
    /*=====================================================
                        Constructors
    =======================================================*/
 
    AffineMatrix4x4();
 
#ifndef SWIG
    operator agx::AffineMatrix4x4() const
    {
      return agx::AffineMatrix4x4((double*)m_data);
    }
 
    AffineMatrix4x4(const agx::AffineMatrix4x4& mat)
    {
      for (auto i = 0; i < 4; i++)
        for (auto j = 0; j < 4; j++)
          this->m_data[i][j] = mat.at(i, j);
    }
 
#endif
    AffineMatrix4x4( const AffineMatrix4x4& mat );
 
    AffineMatrix4x4( double const * const ptr );
 
 
    AffineMatrix4x4(const Quat& rotation, const Vec3& translation = Vec3());
 
    AffineMatrix4x4( const EulerAngles& rotation, const Vec3& translation = Vec3());
 
 
    AffineMatrix4x4( double a00, double a01, double a02, double a03,
                     double a10, double a11, double a12, double a13,
                     double a20, double a21, double a22, double a23,
                     double a30, double a31, double a32, double a33 );
 
 
    ~AffineMatrix4x4();
 
    /*=====================================================
                          Accessors
    =======================================================*/
 
    AffineMatrix4x4 inverse() const;
 
    Vec3 getInvTranslate() const;
 
 
    /*=====================================================
                          Mutators
    =======================================================*/
 
    void set( double const * const ptr );
 
 
    void set( double a00, double a01, double a02, double a03,
                      double a10, double a11, double a12, double a13,
                      double a20, double a21, double a22, double a23,
                      double a30, double a31, double a32, double a33 );
 
    void set(const Quat& q);
 
    void set( const EulerAngles& e );
 
 
    void setRotate(const Quat& q);
 
    void setRotate( const EulerAngles& euler );
 
    void setRotate( const Vec3& from, const Vec3& to );
 
    void setRotate(double angle, const Vec3& axis);
 
    void setRotate( double angle, double x, double y, double z );
 
    void setRotate( double angle1, const Vec3& axis1,
                                double angle2, const Vec3& axis2,
                                double angle3, const Vec3& axis3 );
 
    void setTranslate( const Vec3& t );
 
    void setTranslate(double tx, double ty, double tz);
 
    void setIdentity();
 
 
    /*=====================================================
                        Static methods
    =======================================================*/
 
    /*
    Generates a new matrix of a specific type.
    */
 
 
    static AffineMatrix4x4 crossMatrix(const Vec3& vec);
 
    static AffineMatrix4x4 translate( const Vec3& dv );
 
    static AffineMatrix4x4 translate( double x, double y, double z );
 
    static AffineMatrix4x4 rotate( const Vec3& from, const Vec3& to );
 
 
    static AffineMatrix4x4 rotate( double angle, double x, double y, double z );
 
    static AffineMatrix4x4 rotate( double angle, const Vec3& axis );
 
    static AffineMatrix4x4 rotate( double angle1, const Vec3& axis1,
                                          double angle2, const Vec3& axis2,
                                          double angle3, const Vec3& axis3 );
 
    static AffineMatrix4x4 rotate(const EulerAngles& euler);
 
    /*=====================================================
                        Operators
    =======================================================*/
 
    AffineMatrix4x4 operator* ( const AffineMatrix4x4 &m ) const;
    Matrix4x4 operator* ( const Matrix4x4 &m ) const;
#ifndef SWIG
    AffineMatrix4x4& operator= ( const AffineMatrix4x4& rhs );
    AffineMatrix4x4& operator= (const Matrix4x4& rhs);
#endif
    Vec3 operator* ( const Vec3& v ) const;
    Vec4 operator* ( const Vec4& v ) const;
 
    void operator*= ( const AffineMatrix4x4& other );
    bool operator== ( const AffineMatrix4x4& m ) const;
    bool operator!= ( const AffineMatrix4x4& m ) const;
 
    Vec3 transformPoint(const Vec3& point) const;
 
    Vec3 transformVector(const Vec3& vector) const;
 
    void mult( const AffineMatrix4x4&, const AffineMatrix4x4& );
    // void multSSE(const AffineMatrix4x4& lhs, const AffineMatrix4x4& rhs);
    using Matrix4x4::preMult;
    using Matrix4x4::postMult;
    void preMult( const AffineMatrix4x4& );
    void postMult( const AffineMatrix4x4& );
    AffineMatrix4x4& preMultTranslate( const Vec3& v );
    AffineMatrix4x4& postMultTranslate( const Vec3& v );
 
    double at(int i, int j) const;
 
    void set(double val, int i, int j);
 
 
  protected:
    bool invert( const AffineMatrix4x4& rhs );
  };
 
}
 
 
 
/* ****************************************** */
/* *           IMPLEMENTATION              ** */
/*
/* ****************************************** */
namespace MOMENTUM_NAMESPACE
{
#if !defined(SWIG)
 
  /*=====================================================
                      Constructors
  =======================================================*/
 
 
  inline AffineMatrix4x4::AffineMatrix4x4()
  {
    this->setIdentity();
  }
 
  inline AffineMatrix4x4::AffineMatrix4x4( const AffineMatrix4x4& mat ) : Matrix4x4( mat )
  {
  }
 
 
  inline AffineMatrix4x4::AffineMatrix4x4( double a00, double a01, double a02, double a03,
                                           double a10, double a11, double a12, double a13,
                                           double a20, double a21, double a22, double a23,
                                           double a30, double a31, double a32, double a33 ) : Matrix4x4(a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23, a30, a31, a32, a33)
  {
    agxAssert(this->isRigidTransformation());
  }
 
 
  inline AffineMatrix4x4::AffineMatrix4x4( double const * const ptr )
  {
    set( ptr );
  }
 
 
 
  inline AffineMatrix4x4::AffineMatrix4x4(const Quat& quat, const Vec3& translation) : Matrix4x4(quat, translation)
  {
  }
 
 
 
  inline AffineMatrix4x4::AffineMatrix4x4(EulerAngles const& e, const Vec3& translation ) : Matrix4x4(e, translation)
  {
  }
 
 
 
  inline AffineMatrix4x4::~AffineMatrix4x4()
  {}
 
 
  /*=====================================================
                        Queries
  =======================================================*/
 
 
 
  inline AffineMatrix4x4 AffineMatrix4x4::inverse() const
  {
    AffineMatrix4x4 m;
    m.invert( *this );
    return m;
  }
 
 
  inline Vec3 AffineMatrix4x4::getInvTranslate() const
  {
    double x = this->m_data[3][0];
    double y = this->m_data[3][1];
    double z = this->m_data[3][2];
 
    Vec3 invTranslate;
 
    invTranslate[0] = -( x * this->m_data[0][0] + y* this->m_data[0][1] + z * this->m_data[0][2]);
    invTranslate[1] = -( x * this->m_data[1][0] + y* this->m_data[1][1] + z * this->m_data[1][2]);
    invTranslate[2] = -( x * this->m_data[2][0] + y* this->m_data[2][1] + z * this->m_data[2][2]);
 
    return invTranslate;
  }
 
 
  inline bool AffineMatrix4x4::operator== (const AffineMatrix4x4& m) const
  {
    const int bitCompare = memcmp(this->m_data, m.m_data, sizeof(this->m_data));
    return (bitCompare == 0);
  }
 
 
  inline bool AffineMatrix4x4::operator!= (const AffineMatrix4x4& m) const
  {
    const int bitCompare = memcmp(this->m_data, m.m_data, sizeof(this->m_data));
    return (bitCompare != 0);
  }
 
 
  /*=====================================================
                        Setters
  =======================================================*/
 
  inline void AffineMatrix4x4::set( double const * const ptr )
  {
    memcpy(this->m_data, ptr, sizeof(double)*16);
    agxAssert(this->isRigidTransformation());
  }
 
  inline void AffineMatrix4x4::set( double a00, double a01, double a02, double a03,
                                          double a10, double a11, double a12, double a13,
                                          double a20, double a21, double a22, double a23,
                                          double a30, double a31, double a32, double a33 )
  {
 
    Matrix4x4::set(a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23, a30, a31, a32, a33);
  }
 
 
  inline void AffineMatrix4x4::set(const Quat& q)
  {
    this->setRotate(q);
    this->setTranslate(0.0, 0.0, 0.0);
  }
 
 
 
 
  inline void AffineMatrix4x4::set( const EulerAngles& e )
  {
    std::pair<Matrix4x4, bool> rotation = e.getAsMatrix4x4(*this);
    *this = rotation.first;
    this->setTranslate(0.0, 0.0, 0.0);
  }
 
 
  inline void AffineMatrix4x4::setRotate(const Quat& q)
  {
    Matrix4x4::setRotate(q);
  }
 
 
 
 
  inline void AffineMatrix4x4::setRotate( const EulerAngles& euler )
  {
    std::pair<Matrix4x4, bool> rotation = euler.getAsMatrix4x4(*this);
    *this = rotation.first;
  }
 
 
  inline void AffineMatrix4x4::setRotate( const Vec3& from, const Vec3& to )
  {
    Quat quat;
    quat.setRotate(from,to);
    this->setRotate(quat);
  }
 
 
  inline void AffineMatrix4x4::setRotate( double angle, const Vec3& axis )
  {
    Quat quat;
    quat.setRotate( angle, axis);
    this->setRotate(quat);
  }
 
 
  inline void AffineMatrix4x4::setRotate( double angle, double x, double y, double z )
  {
    Quat quat;
    quat.setRotate( angle, x, y, z);
    this->setRotate(quat);
  }
 
 
  inline void AffineMatrix4x4::setRotate( double angle1, const Vec3& axis1,
                              double angle2, const Vec3& axis2,
                              double angle3, const Vec3& axis3 )
  {
    Quat quat;
    quat.setRotate(angle1, axis1,
                    angle2, axis2,
                    angle3, axis3);
    this->setRotate(quat);
  }
 
 
  inline void AffineMatrix4x4::setTranslate( const Vec3& v )
  {
    this->m_data[3][0] = v[0];
    this->m_data[3][1] = v[1];
    this->m_data[3][2] = v[2];
  }
 
 
  inline void AffineMatrix4x4::setTranslate(double tx, double ty, double tz)
  {
    this->m_data[3][0] = tx;
    this->m_data[3][1] = ty;
    this->m_data[3][2] = tz;
  }
 
 
 
  inline void AffineMatrix4x4::setIdentity()
  {
    this->set(1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1);
  }
 
 
  /*=====================================================
                      Static methods
  =======================================================*/
 
 
  inline AffineMatrix4x4 AffineMatrix4x4::crossMatrix(const Vec3& v)
  {
    return AffineMatrix4x4( 0, -v.z(), v.y(), 0,
                            v.z(), 0, -v.x(), 0,
                            -v.y(), v.x(), 0, 0,
                            0, 0, 0, 1 );
  }
 
 
 
  inline AffineMatrix4x4 AffineMatrix4x4::translate( const Vec3& dv )
  {
    AffineMatrix4x4 m;
    m.setTranslate(dv);
    return m;
  }
 
 
  inline AffineMatrix4x4 AffineMatrix4x4::translate( double x, double y, double z )
  {
    AffineMatrix4x4 m;
    m.setTranslate(x, y, z);
    return m;
  }
 
 
  inline AffineMatrix4x4 AffineMatrix4x4::rotate( const Vec3& from, const Vec3& to )
  {
    AffineMatrix4x4 m;
    m.setRotate(from, to);
    return m;
  }
 
 
  inline AffineMatrix4x4 AffineMatrix4x4::rotate( double angle, double x, double y, double z )
  {
    AffineMatrix4x4 m;
    m.setRotate(angle, x, y, z);
    return m;
  }
 
 
  inline AffineMatrix4x4 AffineMatrix4x4::rotate( double angle, const Vec3& axis )
  {
    AffineMatrix4x4 m;
    m.setRotate(angle, axis);
    return m;
  }
 
 
  inline AffineMatrix4x4 AffineMatrix4x4::rotate( double angle1, const Vec3& axis1,
                                        double angle2, const Vec3& axis2,
                                        double angle3, const Vec3& axis3 )
  {
    AffineMatrix4x4 m;
    m.setRotate(angle1, axis1, angle2, axis2, angle3, axis3);
    return m;
  }
 
  inline AffineMatrix4x4 AffineMatrix4x4::rotate(const EulerAngles& euler)
  {
    AffineMatrix4x4 m;
    m.setRotate(euler);
    return m;
  }
 
 
  /*=====================================================
                      Operators
  =======================================================*/
 
  inline void AffineMatrix4x4::mult( const AffineMatrix4x4& lhs, const AffineMatrix4x4& rhs )
  {
    agx::prefetch<agx::L1>( lhs.m_data );
    agx::prefetch<agx::L1>( rhs.m_data );
 
    if (&lhs==this)
    {
      postMult(rhs);
      return;
    }
    if (&rhs==this)
    {
      preMult(lhs);
      return;
    }
 
    this->m_data[0][0] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 0, 0);
    this->m_data[0][1] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 0, 1);
    this->m_data[0][2] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 0, 2);
 
    this->m_data[1][0] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 1, 0);
    this->m_data[1][1] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 1, 1);
    this->m_data[1][2] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 1, 2);
 
    this->m_data[2][0] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 2, 0);
    this->m_data[2][1] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 2, 1);
    this->m_data[2][2] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 2, 2);
 
    this->m_data[3][0] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 3, 0) + rhs.m_data[3][0];
    this->m_data[3][1] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 3, 1) + rhs.m_data[3][1];
    this->m_data[3][2] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3(lhs, rhs, 3, 2) + rhs.m_data[3][2];
 
  }
 
 
  inline void AffineMatrix4x4::preMult( const AffineMatrix4x4& other )
  {
 
    // more efficient method just use a T[4] for temporary storage.
    double t[4];
    for(int col=0; col<3; ++col) {
      t[0] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( other, *this, 0, col );
      t[1] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( other, *this, 1, col );
      t[2] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( other, *this, 2, col );
      t[3] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( other, *this, 3, col );
      this->m_data[0][col] = t[0];
      this->m_data[1][col] = t[1];
      this->m_data[2][col] = t[2];
      this->m_data[3][col] = t[3] + this->m_data[3][col];
    }
  }
 
 
  inline void AffineMatrix4x4::postMult( const AffineMatrix4x4& other )
  {
 
    // more efficient method just use a T[3] for temporary storage.
    double t[3];
    for(int row=0; row<3; ++row)
    {
      t[0] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( *this, other, row, 0 );
      t[1] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( *this, other, row, 1 );
      t[2] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( *this, other, row, 2 );
 
      MOMENTUM_AFFINEMATRIX4X4_SET_ROW(row, t[0], t[1], t[2] )
    }
    // treat last row differently
    t[0] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( *this, other, 3, 0 ) + other.m_data[3][0];
    t[1] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( *this, other, 3, 1 ) + other.m_data[3][1];
    t[2] = MOMENTUM_AFFINEMATRIX4X4_INNER_PRODUCT_3( *this, other, 3, 2 ) + other.m_data[3][2];
    MOMENTUM_AFFINEMATRIX4X4_SET_ROW(3, t[0], t[1], t[2] )
  }
 
 
  inline AffineMatrix4x4& AffineMatrix4x4::preMultTranslate( const Vec3& v )
  {
    for (unsigned i = 0; i < 3; ++i)
    {
      this->m_data[3][0] += v[i]*this->m_data[i][0];
      this->m_data[3][1] += v[i]*this->m_data[i][1];
      this->m_data[3][2] += v[i]*this->m_data[i][2];
      this->m_data[3][3] += v[i]*this->m_data[i][3];
    }
    return *this;
  }
 
 
  inline AffineMatrix4x4& AffineMatrix4x4::postMultTranslate( const Vec3& v )
  {
    for (unsigned i = 0; i < 3; ++i)
    {
      this->m_data[0][i] += v[i]*this->m_data[0][3];
      this->m_data[1][i] += v[i]*this->m_data[1][3];
      this->m_data[2][i] += v[i]*this->m_data[2][3];
      this->m_data[3][i] += v[i]*this->m_data[3][3];
    }
    return *this;
  }
 
 
 
 
  inline AffineMatrix4x4& AffineMatrix4x4::operator= ( const AffineMatrix4x4& rhs )
  {
    if ( this != &rhs )
      this->set( rhs.ptr() );
 
    return *this;
  }
 
  inline AffineMatrix4x4& AffineMatrix4x4::operator= (const Matrix4x4& rhs)
  {
    if (this != &rhs)
      this->set(rhs.ptr());
 
    return *this;
  }
 
 
 
  inline AffineMatrix4x4 AffineMatrix4x4::operator* ( const AffineMatrix4x4 &m ) const
  {
    AffineMatrix4x4 r;
    r.mult( *this, m );
    return  r;
  }
 
 
  inline Matrix4x4 AffineMatrix4x4::operator* ( const Matrix4x4 &m ) const
  {
    Matrix4x4 r;
    r.mult( *this, m );
    return  r;
  }
 
 
 
  inline void AffineMatrix4x4::operator*= ( const AffineMatrix4x4& other )
  {
    if ( this == &other )
    {
      AffineMatrix4x4 temp( other );
      postMult( temp );
    }
    else postMult( other );
  }
 
 
 
  inline Vec3 AffineMatrix4x4::operator* (const Vec3& v) const
  {
    return postMult(v);
  }
 
 
  inline Vec4 AffineMatrix4x4::operator* (const Vec4& v) const
  {
    return postMult(v);
  }
 
 
  inline Vec3 operator* (const Vec3& v, const AffineMatrix4x4& m)
  {
    return m.preMult(v);
  }
 
 
 
  inline Vec4 operator* (const Vec4& v, const AffineMatrix4x4& m)
  {
    return m.preMult(v);
  }
 
 
 
  inline bool AffineMatrix4x4::invert( const AffineMatrix4x4& rhs)
  {
    double x,y,z;
 
    // diagonal
    this->m_data[0][0] = rhs.m_data[0][0];
    this->m_data[1][1] = rhs.m_data[1][1];
    this->m_data[2][2] = rhs.m_data[2][2];
 
    // rotation
    this->m_data[0][1] = rhs.m_data[1][0];
    this->m_data[1][0] = rhs.m_data[0][1];
    this->m_data[0][2] = rhs.m_data[2][0];
    this->m_data[2][0] = rhs.m_data[0][2];
    this->m_data[1][2] = rhs.m_data[2][1];
    this->m_data[2][1] = rhs.m_data[1][2];
 
    x = rhs.m_data[3][0];
    y = rhs.m_data[3][1];
    z = rhs.m_data[3][2];
 
    // translation
    this->m_data[3][0] = -( x * this->m_data[0][0] + y* this->m_data[1][0] + z * this->m_data[2][0]);
    this->m_data[3][1] = -( x * this->m_data[0][1] + y* this->m_data[1][1] + z * this->m_data[2][1]);
    this->m_data[3][2] = -( x * this->m_data[0][2] + y* this->m_data[1][2] + z * this->m_data[2][2]);
 
    return true;
  }
 
 
  inline double AffineMatrix4x4::at(int i, int j) const
  {
    return double((*this)(i,j));
  }
 
 
  inline void AffineMatrix4x4::set(double val, int i, int j)
  {
    (*this)(i,j) = val;
  }
 
 
 
  inline Vec3 AffineMatrix4x4::transformPoint(const Vec3& point) const
  {
    return point * (*this);
  }
 
 
  inline Vec3 AffineMatrix4x4::transformVector(const Vec3& vector) const
  {
    return this->transform3x3(vector);
  }
#endif   // swig
 
  inline bool equivalent(const AffineMatrix4x4& a, const AffineMatrix4x4& b, double epsilon = double(MOMENTUM_EQUIVALENT_EPSILON))
  {
    return
      agx::equivalent(a(0, 0), b(0, 0), epsilon) &&
      agx::equivalent(a(0, 1), b(0, 1), epsilon) &&
      agx::equivalent(a(0, 2), b(0, 2), epsilon) &&
      agx::equivalent(a(0, 3), b(0, 3), epsilon) &&
      agx::equivalent(a(1, 0), b(1, 0), epsilon) &&
      agx::equivalent(a(1, 1), b(1, 1), epsilon) &&
      agx::equivalent(a(1, 2), b(1, 2), epsilon) &&
      agx::equivalent(a(1, 3), b(1, 3), epsilon) &&
      agx::equivalent(a(2, 0), b(2, 0), epsilon) &&
      agx::equivalent(a(2, 1), b(2, 1), epsilon) &&
      agx::equivalent(a(2, 2), b(2, 2), epsilon) &&
      agx::equivalent(a(2, 3), b(2, 3), epsilon) &&
      agx::equivalent(a(3, 0), b(3, 0), epsilon) &&
      agx::equivalent(a(3, 1), b(3, 1), epsilon) &&
      agx::equivalent(a(3, 2), b(3, 2), epsilon) &&
      agx::equivalent(a(3, 3), b(3, 3), epsilon);
  }
 
 
}
 
 
 
#ifdef _MSC_VER
# pragma warning(pop)
#endif
 
#endif