CUMat4.h

//
//  CUMat4.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a 4d matrix, which is the standard transform
//  matrix in OpenGL.  The class has support for basic camera creation, as well
//  as the traditional transforms.  It can transform any of Vec2, Vec3, and Vec4.
//
//  This version (2018) no longer supports manual vectorization for AVX, Neon.
//  Because these matrices are small, the compiler seems to be able to optimize
//  the naive code better.  Naive code with -O3 outperforms the manual vectorization
//  by almost a full order of magnitude.
//
//  Because math objects are intended to be on the stack, we do not provide
//  any shared pointer support in this class.
//
//  This module is based on an original file from GamePlay3D: http://gameplay3d.org.
//  It has been modified to support the CUGL framework.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 4/3/18

#ifndef __CU_MAT4_H__
#define __CU_MAT4_H__

#include <math.h>
#include <assert.h>
#include "CUMathBase.h"
#include "CUVec2.h"
#include "CUVec3.h"
#include "CUVec4.h"
#include "CURect.h"

namespace cugl {

// Forward references
class Quaternion;
class Affine2;
    
class Mat4 {
#pragma mark Values
public:
#if defined CU_MATH_VECTOR_SSE
    __attribute__((__aligned__(16))) union {
        __m128 col[4];
        float m[16];
    };
#elif defined CU_MATH_VECTOR_NEON64
    __attribute__((__aligned__(16))) union {
        float32x4_t col[4];
        float m[16];
    };
#else
    float m[16];
#endif
    
    static const Mat4 ZERO;
    static const Mat4 ONE;
    static const Mat4 IDENTITY;

    
#pragma mark -
#pragma mark Constructors
public:
    Mat4();
    
    Mat4(float m11, float m12, float m13, float m14,
         float m21, float m22, float m23, float m24,
         float m31, float m32, float m33, float m34,
         float m41, float m42, float m43, float m44);
    
    Mat4(const float* mat);
    
    Mat4(const Mat4& copy);

    Mat4(Mat4&& copy);
    
    Mat4(const Quaternion& rotation) {
        createRotation(rotation, this);
    }
    
    ~Mat4() {}
 
    
#pragma mark -
#pragma mark Static Constructors

    static Mat4 createLookAt(const Vec3& eye, const Vec3& target, const Vec3& up) {
        Mat4 result;
        return *(createLookAt(eye,target,up,&result));
    }

    
    static Mat4* createLookAt(const Vec3& eye, const Vec3& target, const Vec3& up, Mat4* dst);
    
    static Mat4 createLookAt(float eyeX,    float eyeY,     float eyeZ,
                             float targetX, float targetY,  float targetZ,
                             float upX,     float upY,      float upZ) {
        Mat4 result;
        return *(createLookAt(eyeX, eyeY, eyeZ,
                              targetX, targetY, targetZ,
                              upX, upY, upZ, &result));
    }
    
    static Mat4* createLookAt(float eyeX,    float eyeY,     float eyeZ,
                              float targetX, float targetY,  float targetZ,
                              float upX,     float upY,      float upZ,      Mat4* dst);
    

    static Mat4 createPerspective(float fieldOfView, float aspectRatio,
                                  float zNearPlane, float zFarPlane) {
        Mat4 result;
        return *(createPerspective(fieldOfView, aspectRatio, zNearPlane, zFarPlane, &result));
    }

    static Mat4* createPerspective(float fieldOfView, float aspectRatio,
                                   float zNearPlane, float zFarPlane, Mat4* dst);
    
    static Mat4 createOrthographic(float width, float height,
                                   float zNearPlane, float zFarPlane) {
        Mat4 result;
        return *(createOrthographic(width, height, zNearPlane, zFarPlane, &result));
    }

    
    static Mat4* createOrthographic(float width, float height,
                                    float zNearPlane, float zFarPlane, Mat4* dst) {
        float halfWidth = width / 2.0f;
        float halfHeight = height / 2.0f;
        return createOrthographicOffCenter(-halfWidth, halfWidth, -halfHeight, halfHeight,
                                           zNearPlane, zFarPlane, dst);
    }
    
    static Mat4 createOrthographicOffCenter(float left, float right, float bottom, float top,
                                            float zNearPlane, float zFarPlane) {
        Mat4 result;
        return *(createOrthographicOffCenter(left, right, bottom, top, zNearPlane, zFarPlane, &result));
    }

    
    static Mat4* createOrthographicOffCenter(float left, float right, float bottom, float top,
                                             float zNearPlane, float zFarPlane, Mat4* dst);

    static Mat4 createScale(float scale) {
        Mat4 result;
        return *(createScale(scale,&result));
    }
    
    static Mat4* createScale(float scale, Mat4* dst);

    static Mat4 createScale(float sx, float sy, float sz) {
        Mat4 result;
        return *(createScale(sx,sy,sz,&result));
    }

    static Mat4* createScale(float sx, float sy, float sz, Mat4* dst);

    static Mat4 createScale(const Vec3& scale) {
        Mat4 result;
        return *(createScale(scale,&result));
    }

    static Mat4* createScale(const Vec3& scale, Mat4* dst);
  
    static Mat4 createRotation(const Quaternion& quat) {
        Mat4 result;
        return *(createRotation(quat,&result));
    }
    
    static Mat4* createRotation(const Quaternion& quat, Mat4* dst);
    
    static Mat4 createRotation(const Vec3& axis, float angle) {
        Mat4 result;
        return *(createRotation(axis,angle,&result));
    }
    
    static Mat4* createRotation(const Vec3& axis, float angle, Mat4* dst);
    
    static Mat4 createRotationX(float angle) {
        Mat4 result;
        return *(createRotationX(angle,&result));
    }

    static Mat4* createRotationX(float angle, Mat4* dst);
    
    static Mat4 createRotationY(float angle) {
        Mat4 result;
        return *(createRotationY(angle,&result));
    }
    
    static Mat4* createRotationY(float angle, Mat4* dst);
    
    static Mat4 createRotationZ(float angle) {
        Mat4 result;
        return *(createRotationZ(angle,&result));
    }
    
    static Mat4* createRotationZ(float angle, Mat4* dst);

    static Mat4 createTranslation(const Vec3& trans) {
        Mat4 result;
        return *(createTranslation(trans,&result));
    }

    static Mat4* createTranslation(const Vec3& trans, Mat4* dst);
    
    static Mat4 createTranslation(float tx, float ty, float tz) {
        Mat4 result;
        return *(createTranslation(tx,ty,tz,&result));
    }

    static Mat4* createTranslation(float tx, float ty, float tz, Mat4* dst);
    
    
#pragma mark -
#pragma mark Setters

    Mat4& operator=(const Mat4& mat) {
        return set(mat);
    }

    Mat4& operator=(Mat4&& mat) {
        memcpy(this->m, mat.m, sizeof(float)*16);
        return *this;
    }
    
    Mat4& operator=(const float* array) {
        return set(array);
    }
    
    Mat4& operator=(const Quaternion& quat) {
        return set(quat);
    }
    
    Mat4& set(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24,
              float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44);
    
    Mat4& set(const float* mat);
    
    Mat4& set(const Quaternion& quat);
    
    Mat4& set(const Mat4& mat);
    
    Mat4& setIdentity();
    
    Mat4& setZero();
   
    
#pragma mark -
#pragma mark Static Arithmetic
    
    static Mat4* add(const Mat4& mat, float scalar, Mat4* dst);
    
    static Mat4* add(const Mat4& m1, const Mat4& m2, Mat4* dst);

    static Mat4* subtract(const Mat4& mat, float scalar, Mat4* dst);
    
    static Mat4* subtract(const Mat4& m1, const Mat4& m2, Mat4* dst);

    static Mat4* multiply(const Mat4& mat, float scalar, Mat4* dst);

    static Mat4* multiply(const Mat4& m1, const Mat4& m2, Mat4* dst);

    static Mat4* negate(const Mat4& m1, Mat4* dst);

    static Mat4* invert(const Mat4& m1, Mat4* dst);

    static Mat4* transpose(const Mat4& m1, Mat4* dst);
    
#pragma mark -
#pragma mark Arithmetic

    Mat4& add(float scalar) {
        return *(add(*this,scalar,this));
    }
    
    Mat4& add(const Mat4& mat) {
        return *(add(*this,mat,this));
    }
    
    Mat4& subtract(float scalar) {
        return *(subtract(*this,scalar,this));
    }
    
    Mat4& subtract(const Mat4& mat) {
        return *(subtract(*this,mat,this));
    }

    Mat4& multiply(float scalar) {
        return *(multiply(*this,scalar,this));
    }
    
    Mat4& multiply(const Mat4& mat) {
        return *(multiply(*this,mat,this));
    }
    
    Mat4& negate() {
        return *(negate(*this,this));
    }
    
    Mat4 getNegation() const {
        Mat4 result;
        negate(*this,&result);
        return result;
    }
    
    Mat4& invert() {
        return *(invert(*this,this));
    }
    
    Mat4 getInverse() const {
        Mat4 result;
        invert(*this,&result);
        return result;
    }
    
    Mat4& transpose() {
        return *(transpose(*this,this));
    }
    
    Mat4 getTranspose() const {
        Mat4 result;
        transpose(*this,&result);
        return result;
    }
    
    
#pragma mark -
#pragma mark Operators

    Mat4& operator+=(const Mat4& mat) {
        return add(mat);
    }
    
    Mat4& operator-=(const Mat4& mat) {
        return subtract(mat);
    }
    
    Mat4& operator*=(const Mat4& mat) {
        return multiply(mat);
    }
    
    Mat4& operator*=(float scalar) {
        return multiply(scalar);
    }
    
    const Mat4 operator+(const Mat4& mat) const {
        Mat4 result(*this);
        return result.add(mat);
    }
    
    const Mat4 operator-(const Mat4& mat) const {
        Mat4 result(*this);
        return result.subtract(mat);
    }

    const Mat4 operator-() const {
        return getNegation();
    }
    
    const Mat4 operator*(const Mat4& mat) const {
        Mat4 result(*this);
        return result.multiply(mat);
    }
    
    const Mat4 operator*(float scalar) const {
        Mat4 result(*this);
        return result.multiply(scalar);
    }

    
#pragma mark -
#pragma mark Comparisons

    bool isExactly(const Mat4& mat) const;

    bool equals(const Mat4& mat, float variance=CU_MATH_EPSILON) const;

    bool operator==(const Mat4& mat) const {
        return isExactly(mat);
    }
    
    bool operator!=(const Mat4& mat) const {
        return !isExactly(mat);
    }
    
    
#pragma mark -
#pragma mark Matrix Attributes

    bool isIdentity(float variance=CU_MATH_EPSILON) const;

    bool isInvertible(float variance=CU_MATH_EPSILON) const {
        return fabsf(getDeterminant()) > variance;
    }
    
    bool isOrthogonal(float variance=CU_MATH_EPSILON) const;
    
    float getDeterminant() const;

    Vec3 getScale() const;
    
    Quaternion getRotation() const;
    
    Vec3 getTranslation() const;
    
    Vec3 getUpVector() const;
    
    Vec3 getDownVector() const;
    Vec3 getLeftVector() const;
    
    Vec3 getRightVector() const;
    
    Vec3 getForwardVector() const;
    
    Vec3 getBackVector() const;
    

#pragma mark -
#pragma mark Static Vector Operations

    static Vec2* transform(const Mat4& mat, const Vec2& point, Vec2* dst);
    
    static Rect* transform(const Mat4& mat, const Rect& rect, Rect* dst);
    
    static Vec2* transformVector(const Mat4& mat, const Vec2& vec, Vec2* dst);
    
    static Vec3* transform(const Mat4& mat, const Vec3& point, Vec3* dst);
    
    static Vec3* transformVector(const Mat4& mat, const Vec3& vec, Vec3* dst);
    
    static Vec4* transform(const Mat4& mat, const Vec4& vec, Vec4* dst);

    static float* transform(const Mat4& mat, float const* input, float* output, size_t size);


#pragma mark -
#pragma mark Vector Operations

    Vec2 transform(const Vec2& point) const;
    
    Rect transform(const Rect& rect) const;

    Vec2 transformVector(const Vec2& vec) const;
    
    Vec3 transform(const Vec3& point) const;
    
    Vec3 transformVector(const Vec3& vec) const;
    
    Vec4 transform(const Vec4& vec) const;
    
#pragma mark -
#pragma mark Static Matrix Transforms

    static Mat4* rotate(const Mat4& mat, const Quaternion& quat, Mat4* dst) {
        Mat4 result;
        createRotation(quat, &result);
        multiply(mat, result, dst);
        return dst;
    }

    static Mat4* rotate(const Mat4& mat, const Vec3& axis, float angle, Mat4* dst) {
        Mat4 result;
        createRotation(axis, angle, &result);
        multiply(mat, result, dst);
        return dst;
    }

    static Mat4* rotateX(const Mat4& mat, float angle, Mat4* dst) {
        Mat4 result;
        createRotationX(angle, &result);
        multiply(mat, result, dst);
        return dst;
    }
    
    static Mat4* rotateY(const Mat4& mat, float angle, Mat4* dst) {
        Mat4 result;
        createRotationY(angle, &result);
        multiply(mat, result, dst);
        return dst;
    }
    
    static Mat4* rotateZ(const Mat4& mat, float angle, Mat4* dst) {
        Mat4 result;
        createRotationZ(angle, &result);
        multiply(mat, result, dst);
        return dst;
    }

    static Mat4* scale(const Mat4& mat, float value, Mat4* dst) {
        Mat4 result;
        createScale(value, &result);
        multiply(mat, result, dst);
        return dst;
   }
    
    static Mat4* scale(const Mat4& mat, const Vec3& s, Mat4* dst) {
        Mat4 result;
        createScale(s, &result);
        multiply(mat, result, dst);
        return dst;
    }
    
    static Mat4* scale(const Mat4& mat, float sx, float sy, float sz, Mat4* dst) {
        Mat4 result;
        createScale(sx,sy,sz, &result);
        multiply(mat, result, dst);
        return dst;
    }

    static Mat4* translate(const Mat4& mat, const Vec3& t, Mat4* dst) {
        Mat4 result;
        createTranslation(t, &result);
        multiply(mat, result, dst);
        return dst;
    }

    static Mat4* translate(const Mat4& mat, float tx, float ty, float tz, Mat4* dst) {
        Mat4 result;
        createTranslation(tx,ty,tz, &result);
        multiply(mat, result, dst);
        return dst;
    }
    
    static bool decompose(const Mat4& mat, Vec3* scale, Quaternion* rot, Vec3* trans);

    
#pragma mark -
#pragma mark Matrix Transforms

    Mat4& rotate(const Quaternion& q) {
        return *(rotate(*this,q,this));
    }
    
    Mat4& rotate(const Vec3& axis, float angle) {
        return *(rotate(*this,axis,angle,this));
    }

    Mat4& rotateX(float angle) {
        return *(rotateX(*this,angle,this));
    }
    
    Mat4& rotateY(float angle) {
        return *(rotateY(*this,angle,this));
    }
    
    Mat4& rotateZ(float angle) {
        return *(rotateZ(*this,angle,this));
    }
    
    Mat4& scale(float value) {
        return *(scale(*this,value,this));
    }
    
    Mat4& scale(const Vec3& s) {
        return *(scale(*this,s,this));
    }
    
    Mat4& scale(float sx, float sy, float sz) {
        return *(scale(*this,sx,sy,sz,this));
    }

    Mat4& translate(const Vec3& t) {
        return *(translate(*this,t,this));
    }
    
    Mat4& translate(float tx, float ty, float tz) {
        return *(translate(*this,tx,ty,tz,this));
    }
    
    
#pragma mark -
#pragma mark Conversion Methods

    std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }

    operator Affine2() const;
    
    explicit Mat4(const Affine2& aff);
    
    Mat4& operator= (const Affine2& aff);
    
    Mat4& set(const Affine2& aff);
};
    
#pragma mark -
#pragma mark Vector Operations
// To avoid confusion, we NEVER support vector on the right ops.
  
inline Vec2& operator*=(Vec2& v, const Mat4& m) {
    return *(Mat4::transform(m,v,&v));
}
    
inline const Vec2 operator*(const Vec2& v, const Mat4& m) {
    return m.transform(v);
}
    
inline Vec3& operator*=(Vec3& v, const Mat4& m) {
    return *(Mat4::transform(m,v,&v));
}

inline const Vec3 operator*(const Vec3& v, const Mat4& m) {
    return m.transform(v);
}

inline Vec4& operator*=(Vec4& v, const Mat4& m) {
    return *(Mat4::transform(m,v,&v));
}
    
inline const Vec4 operator*(const Vec4& v, const Mat4& m) {
    return m.transform(v);
}
    
inline const Mat4 operator*(float scalar, const Mat4& m) {
    Mat4 result(m);
    return result.multiply(scalar);
}

}

#endif /* __CU_MAT4_H__ */