CUAffine2.h

//
//  CUAffine2.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a 2d affine transform.  It has some of the
//  functionality of Mat4, with a lot less memory footprint.  Profiling suggests
//  that this class is 20% faster than Mat4 when only 2d functionality is needed.
//
//  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: 6/12/16
#ifndef __CU_AFFINE2_H__
#define __CU_AFFINE2_H__

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

namespace cugl {

// Forward reference
class Mat4;

class Affine2 {
#pragma mark Values
public:
    float m[4];
    Vec2 offset;
    
    static const Affine2 ZERO;
    static const Affine2 ONE;
    static const Affine2 IDENTITY;
    
#pragma mark -
#pragma mark Constructors
public:
    Affine2();
    
    Affine2(float m11, float m12, float m21, float m22, float tx, float ty);
    
    Affine2(const float* mat);
    
    Affine2(const Affine2& copy);
    
    Affine2(Affine2&& copy);
    
    ~Affine2() {}
    
    
#pragma mark -
#pragma mark Static Constructors

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

    static Affine2* createScale(float scale, Affine2* dst);
    
    static Affine2 createScale(float sx, float sy) {
        Affine2 result;
        return *(createScale(sx,sy,&result));
    }

    static Affine2* createScale(float sx, float sy, Affine2* dst);
    
    static Affine2 createScale(const Vec2& scale) {
        Affine2 result;
        return *(createScale(scale,&result));
    }

    static Affine2* createScale(const Vec2& scale, Affine2* dst);
    
    static Affine2 createRotation(float angle) {
        Affine2 result;
        return *(createRotation(angle,&result));
    }

    static Affine2* createRotation(float angle, Affine2* dst);
    
    static Affine2 createTranslation(const Vec2& trans) {
        Affine2 result;
        return *(createTranslation(trans,&result));
    }
    
    static Affine2* createTranslation(const Vec2& trans, Affine2* dst);
    
    static Affine2 createTranslation(float tx, float ty) {
        Affine2 result;
        return *(createTranslation(tx,ty,&result));
    }

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

    Affine2& operator=(const Affine2& mat) {
        return set(mat);
    }
    
    Affine2& operator=(Affine2&& mat) {
        memcpy(this->m, mat.m, sizeof(float)*4);
        this->offset = mat.offset;
        return *this;
    }
    
    Affine2& operator=(const float* array) {
        return set(array);
    }
    
    Affine2& set(float m11, float m12, float m21, float m22, float tx, float ty);
    
    Affine2& set(const float* mat);
    
    Affine2& set(const Affine2& mat);
    
    Affine2& setIdentity();
    
    Affine2& setZero();
    
    
#pragma mark -
#pragma mark Static Arithmetic

    static Affine2* add(const Affine2& m, const Vec2& v, Affine2* dst);
    
    static Affine2* subtract(const Affine2& m1, const Vec2& v, Affine2* dst);
    
    static Affine2* multiply(const Affine2& mat, float scalar, Affine2* dst);
    
    static Affine2* multiply(const Affine2& m1, const Affine2& m2, Affine2* dst);
    
    static Affine2* invert(const Affine2& m1, Affine2* dst);
    
#pragma mark -
#pragma mark Arithmetic

    Affine2& add(const Vec2& v) {
        return *(add(*this,v,this));
    }
    
    Affine2& subtract(const Vec2& v) {
        return *(subtract(*this,v,this));
    }
    
    Affine2& multiply(float scalar) {
        return *(multiply(*this,scalar,this));
    }
    
    Affine2& multiply(const Affine2& aff) {
        return *(multiply(*this,aff,this));
    }
    
    Affine2& invert() {
        return *(invert(*this,this));
    }
    
    Affine2 getInverse() const {
        Affine2 result;
        invert(*this,&result);
        return result;
    }
    
#pragma mark -
#pragma mark Operators

    Affine2& operator+=(const Vec2& v) {
        return *(add(*this,v,this));
    }
    
    Affine2& operator-=(const Vec2& v) {
        return *(subtract(*this,v,this));
    }
    
    Affine2& operator*=(float scalar) {
        return *(multiply(*this,scalar,this));
    }

    Affine2& operator*=(const Affine2& aff) {
        return *(multiply(*this,aff,this));
    }
    
    const Affine2 operator+(const Vec2& v) const {
        Affine2 result;
        return *(add(*this,v,&result));
    }
    
    const Affine2 operator-(const Vec2& v) const {
        Affine2 result;
        return *(subtract(*this,v,&result));
    }
    
    const Affine2 operator*(float scalar) const {
        Affine2 result;
        return *(multiply(*this,scalar,&result));
    }

    
    const Affine2 operator*(const Affine2& aff) const {
        Affine2 result;
        return *(multiply(*this,aff,&result));
    }
    
    
#pragma mark -
#pragma mark Comparisons

    bool isExactly(const Affine2& aff) const;
    
    bool equals(const Affine2& mat, float variance=CU_MATH_EPSILON) const;
    
    bool operator==(const Affine2& aff) const {
        return isExactly(aff);
    }
    
    bool operator!=(const Affine2& aff) const {
        return !isExactly(aff);
    }
    
#pragma mark -
#pragma mark Affine Attributes

    bool isIdentity(float variance=0.0f) const;
    
    bool isInvertible(float variance=CU_MATH_EPSILON) const {
        return fabsf(getDeterminant()) > variance;
    }
    
    float getDeterminant() const {
        return m[0]*m[3]-m[2]*m[1];
    }
    
    Vec2 getScale() const {
        Vec2 result;
        decompose(*this,&result,nullptr,nullptr);
        return result;
    }
    
    float getRotation() const {
        float result;
        decompose(*this,nullptr,&result,nullptr);
        return result;
    }
    
    Vec2 getTranslation() const {
        Vec2 result;
        decompose(*this,nullptr,nullptr,&result);
        return result;
    }
    
#pragma mark -
#pragma mark Vector Operations

    static Vec2* transform(const Affine2& aff, const Vec2& point, Vec2* dst);
    
    static Rect* transform(const Affine2& aff, const Rect& rect, Rect* dst);
    
    Vec2 transform(const Vec2& point) const {
        Vec2 result;
        return *(transform(*this,point,&result));
    }
    
    Rect transform(const Rect& rect) const;
    
    
#pragma mark -
#pragma mark Static Transform Manipulation

    static Affine2* rotate(const Affine2& aff, float angle, Affine2* dst) {
        Affine2 result;
        createRotation(angle, &result);
        multiply(aff, result, dst);
        return dst;
    }
    
    static Affine2* scale(const Affine2& aff, float value, Affine2* dst) {
        Affine2 result;
        createScale(value, &result);
        multiply(aff, result, dst);
        return dst;
    }
    
    static Affine2* scale(const Affine2& aff, const Vec2& s, Affine2* dst) {
        Affine2 result;
        createScale(s, &result);
        multiply(aff, result, dst);
        return dst;
    }
    
    static Affine2* scale(const Affine2& aff, float sx, float sy, Affine2* dst) {
        Affine2 result;
        createScale(sx,sy, &result);
        multiply(aff, result, dst);
        return dst;
    }
    
    static Affine2* translate(const Affine2& aff, const Vec2& t, Affine2* dst) {
        Affine2 result;
        createTranslation(t, &result);
        multiply(aff, result, dst);
        return dst;
    }
    
    static Affine2* translate(const Affine2& aff, float tx, float ty, Affine2* dst) {
        Affine2 result;
        createTranslation(tx,ty, &result);
        multiply(aff, result, dst);
        return dst;
    }
    
    static bool decompose(const Affine2& mat, Vec2* scale, float* rot, Vec2* trans);
    
    
#pragma mark -
#pragma mark Matrix Transforms

    Affine2& rotate(float angle) {
        return *(rotate(*this,angle,this));
    }
    
    Affine2& scale(float value) {
        return *(scale(*this,value,this));
    }
    
    Affine2& scale(const Vec2& s) {
        return *(scale(*this,s,this));
    }
    
    Affine2& scale(float sx, float sy) {
        return *(scale(*this,sx,sy,this));
    }
    
    Affine2& translate(const Vec2& t) {
        return *(translate(*this,t,this));
    }
    
    Affine2& translate(float tx, float ty) {
        return *(translate(*this,tx,ty,this));
    }
    
    
#pragma mark -
#pragma mark Conversion Methods

    std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }
    
    operator Mat4() const;
    
    explicit Affine2(const Mat4& mat);
    
    Affine2& operator= (const Mat4& mat);

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