Matrixd.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/Matrixd>
#include <osg/Matrixf>

#include <trBase/Quat.h>

#include <iostream>
#include <string>

namespace trBase
{
    class Matrixf;

    class TR_BASE_EXPORT Matrixd
    {
    public:

        using value_type = double;

        Matrixd();

        Matrixd(const osg::Matrixd& mat);

        Matrixd(const osg::Matrixf& mat);

        Matrixd(const Matrixd& mat);

        Matrixd(const Matrixf& mat);

        explicit Matrixd(float const * const ptr);

        explicit Matrixd(double const * const ptr);

        explicit Matrixd(const Quat& quat);

        Matrixd(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);

        ~Matrixd();

        osg::Matrixd& GetOSGMatrix();

        const osg::Matrixd& GetOSGMatrix() const;

        int Compare(const Matrixd& m) const;

        bool Valid() const;

        bool IsNaN() const;

        void Set(const Matrixd& rhs);

        void Set(const Matrixf& 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 Matrixd& rhs);

        bool Invert_4x3(const Matrixd& rhs);

        bool Invert_4x4(const Matrixd& rhs);

        void OrthoNormalize(const Matrixd& 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 Matrixd& m1, const Matrixd& m2);

        void PreMult(const Matrixd& m);

        void PostMult(const Matrixd& 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 Matrixd Identity(void);

        static Matrixd Scale(const Vec3f& sv);

        static Matrixd Scale(const Vec3d& sv);

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

        static Matrixd Translate(const Vec3f& dv);

        static Matrixd Translate(const Vec3d& dv);

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

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

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

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

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

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

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

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

        static Matrixd Rotate(const Quat& quat);

        static Matrixd Inverse(const Matrixd& matrix);

        static Matrixd OrthoNormal(const Matrixd& matrix);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Matrixd& operator = (const Matrixd& rhs);

        Matrixd& operator = (const Matrixf& rhs);

        bool operator > (const Matrixd& m) const;

        bool operator < (const Matrixd& m) const;

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

        bool operator != (const Matrixd& 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 Matrixd& other);

        Matrixd operator * (const Matrixd &m) const;

        Matrixd operator * (value_type rhs) const;

        Matrixd& operator *= (value_type rhs);

        Matrixd operator / (value_type rhs) const;

        Matrixd& operator /= (value_type rhs);

        Matrixd operator + (const Matrixd& rhs) const;

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

        Matrixd operator - (const Matrixd& rhs) const;

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

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

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

        operator osg::Matrixd () const;

        operator osg::Matrixd& ();

        operator const osg::Matrixd& () const;

        operator osg::Matrixd* ();

    protected:

        osg::Matrixd mMatrix;
    };

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