matrix3x3f.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/math/vec3f.h"
#include "gwnavruntime/containers/stringstream.h"

namespace Kaim
{

class Matrix3x3f
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

public:
    // ------------------------------ Init ------------------------------

    Matrix3x3f() { SetIdentity(); }

    Matrix3x3f(
        KyFloat32 Xx, KyFloat32 Xy, KyFloat32 Xz,
        KyFloat32 Yx, KyFloat32 Yy, KyFloat32 Yz,
        KyFloat32 Zx, KyFloat32 Zy, KyFloat32 Zz)
    {
        Set(Xx, Xy, Xz, Yx, Yy, Yz, Zx, Zy, Zz);
    }

    Matrix3x3f(const Vec3f& X_, const Vec3f& Y_, const Vec3f& Z_) { Set(X_, Y_, Z_); }

    Matrix3x3f(const Vec3f& axis, KyFloat32 angleRad) { SetRotation(axis, angleRad); }

    void SetIdentity() { Set(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f); }

    void Set(
        KyFloat32 Xx, KyFloat32 Xy, KyFloat32 Xz,
        KyFloat32 Yx, KyFloat32 Yy, KyFloat32 Yz,
        KyFloat32 Zx, KyFloat32 Zy, KyFloat32 Zz)
    {
        X.x = Xx; X.y = Xy; X.z = Xz;
        Y.x = Yx; Y.y = Yy; Y.z = Yz;
        Z.x = Zx; Z.y = Zy; Z.z = Zz;
    }

    void Set(const Vec3f& X_, const Vec3f& Y_, const Vec3f& Z_) { Set(X_.x, X_.y, X_.z, Y_.x, Y_.y, Y_.z, Z_.x, Z_.y, Z_.z); }

    void SetRotation(const Vec3f& axis, KyFloat32 angleInRadian);

    void SetYawPitchRoll(KyFloat32 yawInRadian, KyFloat32 pitchInRadian, KyFloat32 rollInRadian);

    // ------------------------------ Main interface ------------------------------

    const Vec3f& Axis(KyUInt32 index) const;  
    Vec3f& Axis(KyUInt32 index);              

    Vec3f      Transform(const Vec3f& to_transform) const;      
    Matrix3x3f Transform(const Matrix3x3f& to_transform) const; 

    void Transform(const Vec3f& to_transform     , Vec3f& transformed) const;      
    void Transform(const Matrix3x3f& to_transform, Matrix3x3f& transformed) const; 

    bool operator==(const Matrix3x3f& other) const { return X == other.X && Y == other.Y && Z == other.Z; }
    bool operator!=(const Matrix3x3f& other) const { return !operator==(other); }

    // ------------------------------ Static methods ------------------------------

    static Matrix3x3f Identity() { return Matrix3x3f(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f); }

    static Matrix3x3f YawPitchRoll(KyFloat32 yawInRadian, KyFloat32 pitchInRadian, KyFloat32 rollInRadian)
    {
        Matrix3x3f M;
        M.SetYawPitchRoll(yawInRadian, pitchInRadian, rollInRadian);
        return M;
    }

    static Matrix3x3f Rotation(const Vec3f& axis, KyFloat32 angleInRadian) { return Matrix3x3f(axis, angleInRadian); }

    // ------------------------------ Data ------------------------------

    Vec3f X; 
    Vec3f Y; 
    Vec3f Z; 
};

inline void SwapEndianness(Endianness::Target e, Matrix3x3f& self)
{
    SwapEndianness(e, self.X);
    SwapEndianness(e, self.Y);
    SwapEndianness(e, self.Z);
}

template <class OSTREAM>
inline OSTREAM& operator<<(OSTREAM& os, const Matrix3x3f& m)
{
    os << "{ X " << m.X << '\n';
    os << "  Y " << m.Y << '\n';
    os << "  Z " << m.Z << " }" << '\n';
    return os;
}

inline const Vec3f& Matrix3x3f::Axis(KyUInt32 index) const
{
    KY_ASSERT(index < 3);
    return *(&X + index);
}

inline Vec3f& Matrix3x3f::Axis(KyUInt32 index)
{
    KY_ASSERT(index < 3);
    return *(&X + index);
}

inline Vec3f Matrix3x3f::Transform(const Vec3f& V) const
{
    return Vec3f(
        X.x * V.x + Y.x * V.y + Z.x * V.z,
        X.y * V.x + Y.y * V.y + Z.y * V.z,
        X.z * V.x + Y.z * V.y + Z.z * V.z);
}

inline void Matrix3x3f::Transform(const Vec3f& V, Vec3f& transformed) const
{
    transformed.x = X.x * V.x + Y.x * V.y + Z.x * V.z;
    transformed.y = X.y * V.x + Y.y * V.y + Z.y * V.z;
    transformed.z = X.z * V.x + Y.z * V.y + Z.z * V.z;
}

inline Matrix3x3f Matrix3x3f::Transform(const Matrix3x3f& to_transform) const
{
    return Matrix3x3f(
        Transform(to_transform.X),
        Transform(to_transform.Y),
        Transform(to_transform.Z));
}

inline void Matrix3x3f::Transform(const Matrix3x3f& to_transform, Matrix3x3f& transformed) const
{
    transformed.X = Transform(to_transform.X);
    transformed.Y = Transform(to_transform.Y);
    transformed.Z = Transform(to_transform.Z);
}

}