AffineMatrix.h

Go to the documentation of this file.

// File: AffineMatrix.h
// Description: Wrapper class for 2D matrices. Contains basic manipulation necessary for transformations
// Author(s): Ori Balashov (ori.balashov@digipen.edu) Base Implementation
//            Aidan Hartman (aidan.hartman@digipen.edu) Added additional functionality
// 2025 / 09 / 17
// (C) Digipen 2025
//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
#pragma once
 
#include "Vector4D.h"
#include "Eigen/Dense"

struct AffineMatrix
{
    static auto bindLuaTypes(sol::state& lua) -> void;
    AffineMatrix();
    AffineMatrix(const AffineMatrix&) = default;
    AffineMatrix(const Eigen::Matrix4f&);
    auto operator=(const AffineMatrix&) -> AffineMatrix& = default;
    ~AffineMatrix()                                      = default;
 
    // Sets up the top left square
    AffineMatrix(float x1, float x2, float y1, float y2);
    // Sets up the whole thing
    AffineMatrix(float x1, float x2, float x3, float x4, float y1, float y2, float y3, float y4, float z1, float z2,
                 float z3, float z4, float w1, float w2, float w3, float w4);
 
    auto operator*=(const AffineMatrix& Other) -> AffineMatrix&;
    auto operator*(const AffineMatrix& Other) const -> AffineMatrix;

    friend auto operator*(float scalar, const AffineMatrix& matrix) -> AffineMatrix;

    friend auto operator*(const AffineMatrix& matrix, float scalar) -> AffineMatrix;

    friend auto operator*=(AffineMatrix& matrix, float scalar) -> AffineMatrix&;
 

    friend auto operator*(const AffineMatrix& rhs, const Vector4D& lhs) -> Vector4D;
    friend auto operator*=(Vector4D& rhs, const AffineMatrix& lhs) -> Vector4D&;
 
 
    // Makes matrices correspond to the related transformations
    auto identity() -> AffineMatrix&;
    auto transpose() -> AffineMatrix&;
 
    auto scale(float s) -> AffineMatrix&;
    auto scale(float x, float y) -> AffineMatrix&;
    auto scale(const Vector4D& vector) -> AffineMatrix&;
 
 
    auto rotate(float angle) -> AffineMatrix&;
    auto translate(float x, float y) -> AffineMatrix&;
    auto translate(const Vector4D& vector) -> AffineMatrix&;
 
    // Operators for RHS and LHS
    //You can access elements inside of the matrix through calling "[matrix name](x,y)"
    /*
     *  AffineMatrix myMatrix = new Matrix(1, 0, 0, 1);
     *  myMatrix(0,1) = 3;
     *  int newInt = myMatrix(1,1);
     */
    auto operator()(int row, int col) -> float&;
    auto operator()(int row, int col) const -> float;
 
    auto get(int row, int col) -> float&;
    auto get(int row, int col) const -> float;
 
    auto data() const -> const float*;
    auto data() -> float*;
 
    auto invert() -> void;
 
    friend auto to_json(json& j, const AffineMatrix& a)
    {
        j.at("v1").push_back(a.get(0, 0));
        j.at("v1").push_back(a.get(0, 1));
        j.at("v1").push_back(a.get(0, 2));
        j.at("v1").push_back(a.get(0, 3));
 
        j.at("v2").push_back(a.get(1, 0));
        j.at("v2").push_back(a.get(1, 1));
        j.at("v2").push_back(a.get(1, 2));
        j.at("v2").push_back(a.get(1, 3));
 
        j.at("v3").push_back(a.get(2, 0));
        j.at("v3").push_back(a.get(2, 1));
        j.at("v3").push_back(a.get(2, 2));
        j.at("v3").push_back(a.get(2, 3));
 
        j.at("v4").push_back(a.get(3, 0));
        j.at("v4").push_back(a.get(3, 1));
        j.at("v4").push_back(a.get(3, 2));
        j.at("v4").push_back(a.get(3, 3));
    }
 
    friend auto from_json(const json& j, AffineMatrix& a) -> void
    {
        a.get(0, 0) = j.at("v1")[0];
        a.get(0, 1) = j.at("v1")[1];
        a.get(0, 2) = j.at("v1")[2];
        a.get(0, 3) = j.at("v1")[3];
 
        a.get(1, 0) = j.at("v2")[0];
        a.get(1, 1) = j.at("v2")[1];
        a.get(1, 2) = j.at("v2")[2];
        a.get(1, 3) = j.at("v2")[3];
 
        a.get(2, 0) = j.at("v3")[0];
        a.get(2, 1) = j.at("v3")[1];
        a.get(2, 2) = j.at("v3")[2];
        a.get(2, 3) = j.at("v3")[3];
 
        a.get(3, 0) = j.at("v4")[0];
        a.get(3, 1) = j.at("v4")[1];
        a.get(3, 2) = j.at("v4")[2];
        a.get(3, 3) = j.at("v4")[3];
    }
 
private:
    // 3 Dimensions to support affine
    Eigen::Matrix4f matrix;
};