Vector4D.h

Go to the documentation of this file.

// File: Vector4D.h
// Description: Wrapper class of 2D vectors. Has very little functionality currently implemented
// Author(s): Ori Balashov (ori.balashov@digipen.edu) Base Implementation
//            Aidan Hartman (aidan.hartman@digipen.edu) Added additional functionality
//            Marcelo Escamilla (marcelo.escamilla@digipen.edu) Added JSON Serialization
// 2025 / 09 / 17
// (C) Digipen 2025
//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
#pragma once
 
#include "Eigen/Dense"
#include "System/Json.h"
 
namespace sol
{
class state;
}
 
struct AffineMatrix;
 
struct Vector4D
{
    static auto bindLuaTypes(sol::state& lua) -> void;
    Vector4D();
    Vector4D(const Eigen::Vector4f& rhs);
    Vector4D(float x, float y, float z, float w);
    
    auto operator=(const Eigen::Vector4f& rhs) -> Vector4D&;
 
    auto operator+=(const Vector4D& rhs) -> Vector4D&;
    auto operator+(const Vector4D& rhs) const -> Vector4D;
    auto operator-=(const Vector4D& rhs) -> Vector4D&;
    auto operator-(const Vector4D& rhs) const -> Vector4D;
    auto operator==(const Vector4D& rhs) const -> bool;
    auto operator>(const Vector4D& rhs) const -> bool;
    auto operator<(const Vector4D& rhs) const -> bool;
    // Vector scaling
    auto operator*=(float scalar) -> Vector4D&;
    auto operator*(float scalar) const -> Vector4D;
    friend auto operator*(float scalar, const Vector4D&) -> Vector4D;
    auto operator-() const -> Vector4D;

    friend auto operator*(const AffineMatrix& rhs, const Vector4D& lhs) -> Vector4D;
    friend auto operator*=(Vector4D& rhs, const AffineMatrix& lhs) -> Vector4D&;

    auto operator*(const Vector4D& rhs) const -> float;

    auto length() const -> float;
 
    auto x() const -> const float&
    {
        return vector[0];
    }
 
    auto x() -> float&
    {
        return vector[0];
    }
 
    auto y() const -> const float&
    {
        return vector[1];
    }
 
    auto y() -> float&
    {
        return vector[1];
    }
 
    auto z() const -> const float&
    {
        return vector[2];
    }
 
    auto z() -> float&
    {
        return vector[2];
    }
 
    auto w() const -> const float&
    {
        return vector[3];
    }
 
    auto w() -> float&
    {
        return vector[3];
    }
 
    // utility functions
    auto data() const -> const float*
    {
        return vector.data();
    }
 
    auto data() -> float*
    {
        return vector.data();
    }
 
    friend auto from_json(const json& j, Vector4D& v) -> void;
    friend auto to_json(json& j, const Vector4D& v) -> void;
    
    auto to_string() -> std::string;
 
private:
    Eigen::Vector4f vector;
    
    auto x(float x) -> void
    {
        vector.x() = x;
    }

    auto y(float y) -> void
    {
        vector.y() = y;
    }

    auto z(float z) -> void
    {
        vector.z() = z;
    }

    auto w(float w) -> void
    {
        vector.w() = w;
    }
};