Matrix4.h

#pragma once
 
#include "Types.h"
#include "math/Matrix4.h"
#include "math/Math.h"
#include "Vector3.h"
 
namespace SharpKmyMath{
 
    public value class Matrix4{
    public:
 
        float m00, m01, m02, m03;
        float m10, m11, m12, m13;
        float m20, m21, m22, m23;
        float m30, m31, m32, m33;
 
        Matrix4(float _m00, float _m01, float _m02, float _m03,
            float _m10, float _m11, float _m12, float _m13,
            float _m20, float _m21, float _m22, float _m23,
            float _m30, float _m31, float _m32, float _m33)
        {
            m00 = _m00;
            m01 = _m01;
            m02 = _m02;
            m03 = _m03;
 
            m10 = _m10;
            m11 = _m11;
            m12 = _m12;
            m13 = _m13;
 
            m20 = _m20;
            m21 = _m21;
            m22 = _m22;
            m23 = _m23;
 
            m30 = _m30;
            m31 = _m31;
            m32 = _m32;
            m33 = _m33;
        }
 
        static Matrix4 perspectiveFOV(float fov, float asp, float znear, float zfar)
        {
            auto n = kmyMath::Matrix4::perspectiveFOV(fov * 2, asp, znear, zfar);
            return fromNativeMatrix4(n);
        }
 
        static Matrix4 ortho(float left, float right, float top, float bottom, float znear, float zfar)
        {
            auto n = kmyMath::Matrix4::ortho(left, right, top, bottom, znear, zfar);
            return fromNativeMatrix4(n);
        }
 
        static Matrix4 translate(float x, float y, float z)
        {
            return Matrix4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1);
        }
 
        static Matrix4 scale(float x, float y, float z)
        {
            return Matrix4(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1);
        }
 
        static Matrix4 rotateX(float r)
        {
            Matrix4 retval;
            retval = identity();
            retval.m11 = cos(r);
            retval.m12 = sin(r);
            retval.m21 = -sin(r);
            retval.m22 = cos(r);
            return retval;
        }
 
        static Matrix4 rotateY(float r)
        {
            Matrix4 retval;
            retval = identity();
            retval.m00 = cos(r);
            retval.m02 = -sin(r);
            retval.m20 = sin(r);
            retval.m22 = cos(r);
            return retval;
        }
 
        static Matrix4 rotateZ(float r)
        {
            Matrix4 retval;
            retval = identity();
            retval.m00 = cos(r);
            retval.m01 = sin(r);
            retval.m10 = -sin(r);
            retval.m11 = cos(r);
            return retval;
        }
 
        static Matrix4 identity()
        {
            return Matrix4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
        }
 
        static Matrix4 inverse(Matrix4 m)
        {
            kmyMath::Matrix4 nm = m.toNativeMatrix4();
            nm = kmyMath::Matrix4::inverse(nm);
            Matrix4 ret = fromNativeMatrix4(nm);
            return ret;
        }
 
        static Matrix4 operator*(Matrix4 m1, Matrix4 m2)
        {
            Matrix4 ret;
 
            kmyMath::Matrix4 nm1 = m1.toNativeMatrix4();
            kmyMath::Matrix4 nm2 = m2.toNativeMatrix4();
 
            kmyMath::Matrix4 res = nm1 * nm2;
 
            return fromNativeMatrix4(res);
        }
 
        static Matrix4 lookat( Vector3 eye, Vector3 target, Vector3 upvec )
        {
            Matrix4 ret;
 
            Vector3 zaxis, xaxis, yaxis;
 
            zaxis = Vector3::normalize(target - eye);
            xaxis = Vector3::normalize(Vector3::crossProduct(zaxis, upvec));
            yaxis = Vector3::crossProduct(xaxis, zaxis);
 
            ret.m00 = xaxis.x;
            ret.m01 = xaxis.y;
            ret.m02 = xaxis.z;
            ret.m03 = 0;
 
            ret.m10 = yaxis.x;
            ret.m11 = yaxis.y;
            ret.m12 = yaxis.z;
            ret.m13 = 0;
 
            ret.m20 = -zaxis.x;
            ret.m21 = -zaxis.y;
            ret.m22 = -zaxis.z;
            ret.m23 = 0;
 
            ret.m30 = eye.x;
            ret.m31 = eye.y;
            ret.m32 = eye.z;
            ret.m33 = 1;
 
            return ret;
        }
 
        static Vector4 operator*(Matrix4 m, Vector3 v)
        {
            Vector4 result;
            result.x = m.m00 * v.x + m.m10 * v.y + m.m20 * v.z + m.m30;
            result.y = m.m01 * v.x + m.m11 * v.y + m.m21 * v.z + m.m31;
            result.z = m.m02 * v.x + m.m12 * v.y + m.m22 * v.z + m.m32;
            result.w = m.m03 * v.x + m.m13 * v.y + m.m23 * v.z + m.m33;
            return result;
        }
 
        static Vector4 operator*(Matrix4 m, Vector4 v)
        {
            Vector4 result;
            result.x = m.m00 * v.x + m.m10 * v.y + m.m20 * v.z + m.m30 * v.w;
            result.y = m.m01 * v.x + m.m11 * v.y + m.m21 * v.z + m.m31 * v.w;
            result.z = m.m02 * v.x + m.m12 * v.y + m.m22 * v.z + m.m32 * v.w;
            result.w = m.m03 * v.x + m.m13 * v.y + m.m23 * v.z + m.m33 * v.w;
            return result;
        }
 
        kmyMath::Matrix4 toNativeMatrix4()
        {
            kmyMath::Matrix4 m;
            m.m00 = m00;
            m.m01 = m01;
            m.m02 = m02;
            m.m03 = m03;
 
            m.m10 = m10;
            m.m11 = m11;
            m.m12 = m12;
            m.m13 = m13;
 
            m.m20 = m20;
            m.m21 = m21;
            m.m22 = m22;
            m.m23 = m23;
 
            m.m30 = m30;
            m.m31 = m31;
            m.m32 = m32;
            m.m33 = m33;
            return m;
        }
 
        static Matrix4 fromNativeMatrix4(const kmyMath::Matrix4 &m)
        {
            Matrix4 ret;
            ret.m00 = m.m00;
            ret.m01 = m.m01;
            ret.m02 = m.m02;
            ret.m03 = m.m03;
 
            ret.m10 = m.m10;
            ret.m11 = m.m11;
            ret.m12 = m.m12;
            ret.m13 = m.m13;
 
            ret.m20 = m.m20;
            ret.m21 = m.m21;
            ret.m22 = m.m22;
            ret.m23 = m.m23;
 
            ret.m30 = m.m30;
            ret.m31 = m.m31;
            ret.m32 = m.m32;
            ret.m33 = m.m33;
            return ret;
        }
 
        Vector3 translation()
        {
            return Vector3(m30, m31, m32);
        }
 
        Vector3 scale()
        {
            return Vector3(
                sqrt(m00 * m00 + m01 * m01 + m02 * m02),
                sqrt(m10 * m10 + m11 * m11 + m12 * m12),
                sqrt(m20 * m20 + m21 * m21 + m22 * m22)
            );
        }
 
        Matrix4 scaleIdentity()
        {
            auto x = sqrt(m00 * m00 + m01 * m01 + m02 * m02);
            auto y = sqrt(m10 * m10 + m11 * m11 + m12 * m12);
            auto z = sqrt(m20 * m20 + m21 * m21 + m22 * m22);
 
            //�T�C�Y���O�Ȃ疳��
            if (x == 0.0f || y == 0.0f || z == 0.0f) {
                PRINTF("Matrix4 scale reset error");
                return identity();
            }
 
            Matrix4 r = Matrix4(*this);
            r.m00 /= x;
            r.m01 /= x;
            r.m02 /= x;
 
            r.m10 /= y;
            r.m11 /= y;
            r.m12 /= y;
 
            r.m20 /= z;
            r.m21 /= z;
            r.m22 /= z;
 
            return r;
        }
 
        Matrix4 translateIdentity()
        {
            Matrix4 r = Matrix4(*this);
            r.m30 = r.m31 = r.m32 = 0.0f;
            return r;
        }
 
        Vector3 getEularZXY()
        {
            Matrix4 r = Matrix4(*this);
            kmyMath::Matrix4 nm = r.toNativeMatrix4();
            kmyMath::Vector3 v = nm.getEularZXY();
            return Vector3(v.x, v.y, v.z);
        }
 
        Vector3 getScale()
        {
            kmyMath::Matrix4 nm = toNativeMatrix4();
            auto v = nm.getScale();
            return Vector3(v.x, v.y, v.z);
        }
 
        Vector3 front()
        {
            return Vector3(m20, m21, m22);
        }
 
        Vector3 back()
        {
            return -Vector3(m20, m21, m22);
        }
 
        Vector3 left()
        {
            return Vector3(m00, m01, m02);
        }
 
        Vector3 right()
        {
            return -Vector3(m00, m01, m02);
        }
 
        Vector3 up()
        {
            return Vector3(m10, m11, m12);
        }
 
        Vector3 down()
        {
            return -Vector3(m10, m11, m12);
        }
    };
 
 
 
}