Matrixf.h

Go to the documentation of this file.

/*
* True Reality Open Source Game and Simulation Engine
* Copyright © 2021 Acid Rain Studios LLC
*
* This library is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 3.0 of the License, or (at your option)
* any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* @author Maxim Serebrennik
*/
#pragma once

#include <trBase/Export.h>

#include <osg/Matrixf>
#include <osg/Matrixd>

#include <trBase/Matrixd.h>
#include <trBase/Quat.h>

#include <iostream>
#include <string>

namespace trBase
{
    class Matrixd;

    class TR_BASE_EXPORT Matrixf
    {
    public:

        using value_type = float;

        Matrixf();

        Matrixf(const osg::Matrixf& mat);

        Matrixf(const osg::Matrixd& mat);

        Matrixf(const Matrixf& mat);

        Matrixf(const Matrixd& mat);

        explicit Matrixf(float const * const ptr);

        explicit Matrixf(double const * const ptr);

        explicit Matrixf(const Quat& quat);

        Matrixf(value_type a00, value_type a01, value_type a02, value_type a03,
            value_type a10, value_type a11, value_type a12, value_type a13,
            value_type a20, value_type a21, value_type a22, value_type a23,
            value_type a30, value_type a31, value_type a32, value_type a33);

        ~Matrixf();

        osg::Matrixf& GetOSGMatrix();

        const osg::Matrixf& GetOSGMatrix() const;

        int Compare(const Matrixf& m) const;

        bool Valid() const;

        bool IsNaN() const;

        void Set(const Matrixf& rhs);

        void Set(const Matrixd& rhs);

        void Set(float const * const ptr);

        void Set(double const * const ptr);

        void Set(value_type a00, value_type a01, value_type a02, value_type a03,
            value_type a10, value_type a11, value_type a12, value_type a13,
            value_type a20, value_type a21, value_type a22, value_type a23,
            value_type a30, value_type a31, value_type a32, value_type a33);

        value_type* Ptr();

        const value_type* Ptr() const;

        void MakeIdentity();

        void MakeScale(const Vec3f& v);

        void MakeScale(const Vec3d& v);

        void MakeScale(value_type x, value_type y, value_type z);

        void MakeTranslate(const Vec3f& v);

        void MakeTranslate(const Vec3d& v);

        void MakeTranslate(value_type x, value_type y, value_type z);

        void MakeRotate(const Vec3f& from, const Vec3f& to);

        void MakeRotate(const Vec3d& from, const Vec3d& to);

        void MakeRotate(value_type angle, const Vec3f& axis);

        void MakeRotate(value_type angle, const Vec3d& axis);

        void MakeRotate(value_type angle, value_type x, value_type y, value_type z);

        void MakeRotate(const Quat& q);

        void MakeRotate(value_type angle1, const Vec3f& axis1, value_type angle2, const Vec3f& axis2, value_type angle3, const Vec3f& axis3);

        void MakeRotate(value_type angle1, const Vec3d& axis1, value_type angle2, const Vec3d& axis2, value_type angle3, const Vec3d& axis3);

        void Decompose(Vec3f& translation, Quat& rotation, Vec3f& scale, Quat& so) const;

        void Decompose(Vec3d& translation, Quat& rotation, Vec3d& scale, Quat& so) const;

        void MakeOrtho(double left, double right, double bottom, double top, double zNear, double zFar);

        void MakeOrtho(float left, float right, float bottom, float top, float zNear, float zFar);

        bool GetOrtho(double& left, double& right, double& bottom, double& top, double& zNear, double& zFar) const;

        bool GetOrtho(float& left, float& right, float& bottom, float& top, float& zNear, float& zFar) const;

        void MakeOrtho2D(double left, double right, double bottom, double top);

        void MakeOrtho2D(float left, float right, float bottom, float top);

        void MakeFrustum(double left, double right, double bottom, double top, double zNear, double zFar);

        void MakeFrustum(float left, float right, float bottom, float top, float zNear, float zFar);

        bool GetFrustum(double& left, double& right, double& bottom, double& top, double& zNear, double& zFar) const;

        bool GetFrustum(float& left, float& right, float& bottom, float& top, float& zNear, float& zFar) const;

        void MakePerspective(double fovy, double aspectRatio, double zNear, double zFar);

        void MakePerspective(float fovy, float aspectRatio, float zNear, float zFar);

        bool GetPerspective(double& fovy, double& aspectRatio, double& zNear, double& zFar) const;

        bool GetPerspective(float& fovy, float& aspectRatio, float& zNear, float& zFar) const;

        void MakeLookAt(const Vec3f& eye, const Vec3f& center, const Vec3f& up);

        void MakeLookAt(const Vec3d& eye, const Vec3d& center, const Vec3d& up);

        void GetLookAt(Vec3f& eye, Vec3f& center, Vec3f& up, value_type lookDistance = 1.0f) const;

        void GetLookAt(Vec3d& eye, Vec3d& center, Vec3d& up, value_type lookDistance = 1.0f) const;

        bool Invert(const Matrixf& rhs);

        bool Invert_4x3(const Matrixf& rhs);

        bool Invert_4x4(const Matrixf& rhs);

        void OrthoNormalize(const Matrixf& rhs);

        void SetRotate(const Quat& q);

        Quat GetRotate() const;

        void SetTrans(value_type tx, value_type ty, value_type tz);

        void SetTrans(const Vec3f& v);

        void SetTrans(const Vec3d& v);

        Vec3d GetTrans() const;

        Vec3d GetScale() const;

        void SetScale(value_type x, value_type y, value_type z);

        void SetScale(const Vec3f& v);

        void SetScale(const Vec3d& v);

        Vec3f PreMult(const Vec3f& v) const;

        Vec3d PreMult(const Vec3d& v) const;

        Vec3f PostMult(const Vec3f& v) const;

        Vec3d PostMult(const Vec3d& v) const;

        Vec4f PreMult(const Vec4f& v) const;

        Vec4d PreMult(const Vec4d& v) const;

        Vec4f PostMult(const Vec4f& v) const;

        Vec4d PostMult(const Vec4d& v) const;

        void Mult(const Matrixf& m1, const Matrixf& m2);

        void PreMult(const Matrixf& m);

        void PostMult(const Matrixf& m);

        void PreMultTranslate(const Vec3d& v);

        void PreMultTranslate(const Vec3f& v);

        void PostMultTranslate(const Vec3d& v);

        void PostMultTranslate(const Vec3f& v);

        void PreMultScale(const Vec3d& v);

        void PreMultScale(const Vec3f& v);

        void PostMultScale(const Vec3d& v);

        void PostMultScale(const Vec3f& v);

        void PreMultRotate(const Quat& q);

        void PostMultRotate(const Quat& q);

        std::string ToString(int precision = -1);

        static Matrixf Identity(void);

        static Matrixf Scale(const Vec3f& sv);

        static Matrixf Scale(const Vec3d& sv);

        static Matrixf Scale(value_type sx, value_type sy, value_type sz);

        static Matrixf Translate(const Vec3f& dv);

        static Matrixf Translate(const Vec3d& dv);

        static Matrixf Translate(value_type x, value_type y, value_type z);

        static Matrixf Rotate(const Vec3f& from, const Vec3f& to);

        static Matrixf Rotate(const Vec3d& from, const Vec3d& to);

        static Matrixf Rotate(value_type angle, value_type x, value_type y, value_type z);

        static Matrixf Rotate(value_type angle, const Vec3f& axis);

        static Matrixf Rotate(value_type angle, const Vec3d& axis);

        static Matrixf Rotate(value_type angle1, const Vec3f& axis1, value_type angle2, const Vec3f& axis2, value_type angle3, const Vec3f& axis3);

        static Matrixf Rotate(value_type angle1, const Vec3d& axis1, value_type angle2, const Vec3d& axis2, value_type angle3, const Vec3d& axis3);

        static Matrixf Rotate(const Quat& quat);

        static Matrixf Inverse(const Matrixf& matrix);

        static Matrixf OrthoNormal(const Matrixf& matrix);

        static Matrixf Ortho(double left, double right, double bottom, double top, double zNear, double zFar);

        static Matrixf Ortho(float left, float right, float bottom, float top, float zNear, float zFar);

        static Matrixf Ortho2D(double left, double right, double bottom, double top);

        static Matrixf Ortho2D(float left, float right, float bottom, float top);

        static Matrixf Frustum(double left, double right, double bottom, double top, double zNear, double zFar);

        static Matrixf Frustum(float left, float right, float bottom, float top, float zNear, float zFar);

        static Matrixf Perspective(float fovy, float aspectRatio, float zNear, float zFar);

        static Matrixf Perspective(double fovy, double aspectRatio, double zNear, double zFar);

        static Matrixf LookAt(const Vec3f& eye, const Vec3f& center, const Vec3f& up);

        static Matrixf LookAt(const Vec3d& eye, const Vec3d& center, const Vec3d& up);

        static Vec3f Transform3x3(const Vec3f& v, const Matrixf& m);

        static Vec3d Transform3x3(const Vec3d& v, const Matrixf& m);

        static Vec3f Transform3x3(const Matrixf& m, const Vec3f& v);

        static Vec3d Transform3x3(const Matrixf& m, const Vec3d& v);

        Matrixf& operator = (const Matrixf& rhs);

        Matrixf& operator = (const Matrixd& rhs);

        bool operator > (const Matrixf& m) const;

        bool operator < (const Matrixf& m) const;

        bool operator == (const Matrixf& m) const;

        bool operator != (const Matrixf& m) const;

        Vec3f operator* (const Vec3f& v) const;

        Vec3d operator* (const Vec3d& v) const;

        Vec4f operator* (const Vec4f& v) const;

        Vec4d operator* (const Vec4d& v) const;

        void operator *= (const Matrixf& other);

        Matrixf operator * (const Matrixf &m) const;

        Matrixf operator * (value_type rhs) const;

        Matrixf& operator *= (value_type rhs);

        Matrixf operator / (value_type rhs) const;

        Matrixf& operator /= (value_type rhs);

        Matrixf operator + (const Matrixf& rhs) const;

        Matrixf& operator += (const Matrixf& rhs);

        Matrixf operator - (const Matrixf& rhs) const;

        Matrixf& operator -= (const Matrixf& rhs);

        value_type& operator ()(int row, int col);

        value_type operator ()(int row, int col) const;

        operator osg::Matrixf () const;

        operator osg::Matrixf& ();

        operator const osg::Matrixf& () const;

        operator osg::Matrixf* ();

    protected:

        osg::Matrixf mMatrix;
    };

    TR_BASE_EXPORT std::ostream& operator << (std::ostream& ios, const Matrixf& q);
}