Vector.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Settings/Warnings.hpp>
AH_DIAGNOSTIC_WERROR() // Enable errors on warnings
 
#include <AH/Arduino-Wrapper.h> // Print
#include <AH/STL/cmath>         // std::sqrt
 
#ifndef ARDUINO
#include <iosfwd> // std::ostream
#endif
 
BEGIN_AH_NAMESPACE
 
 
struct Vec2f {
    float x = 0.0; 
    float y = 0.0; 
 
    Vec2f() = default;
    Vec2f(float x, float y) : x(x), y(y) {}
 
    Vec2f &operator+=(Vec2f rhs) {
        x += rhs.x;
        y += rhs.y;
        return *this;
    }
    Vec2f operator+(Vec2f rhs) const {
        Vec2f result = *this;
        result += rhs;
        return result;
    }
 
    Vec2f operator-() const { return {-x, -y}; }
    Vec2f &operator-=(Vec2f rhs) { return *this += -rhs; }
    Vec2f operator-(Vec2f rhs) const {
        Vec2f result = *this;
        result -= rhs;
        return result;
    }
 
    Vec2f &operator*=(float rhs) {
        x *= rhs;
        y *= rhs;
        return *this;
    }
    Vec2f operator*(float rhs) const {
        Vec2f result = *this;
        result *= rhs;
        return result;
    }
 
    Vec2f &operator/=(float rhs) {
        x /= rhs;
        y /= rhs;
        return *this;
    }
    Vec2f operator/(float rhs) const {
        Vec2f result = *this;
        result /= rhs;
        return result;
    }
 
    float operator*(Vec2f rhs) const {
        return this->x * rhs.x + this->y * rhs.y;
    }
 
    float normSquared() const { return (*this) * (*this); }
    float norm() const {
        // return std::sqrt(normSquared()); // faster but less accurate
        return std::hypot(x, y);
    }
    Vec2f &normalize() { return *this /= norm(); }
    Vec2f normalized() const { return *this / norm(); }
 
    bool operator==(Vec2f rhs) const {
        return this->x == rhs.x && this->y == rhs.y;
    }
    bool operator!=(Vec2f rhs) const { return !(*this == rhs); }
};
 
inline Vec2f operator*(float lhs, Vec2f rhs) {
    return {lhs * rhs.x, lhs * rhs.y};
}
 
struct Vec3f {
    float x = 0.0; 
    float y = 0.0; 
    float z = 0.0; 
 
    Vec3f() = default;
    Vec3f(float x, float y, float z) : x(x), y(y), z(z) {}
    Vec3f(const Vec3f &) = default;
    Vec3f(const volatile Vec3f &other) : x(other.x), y(other.y), z(other.z) {}
    void operator=(const Vec3f &other) volatile {
        this->x = other.x;
        this->y = other.y;
        this->z = other.z;
    }
 
    Vec3f &operator+=(Vec3f rhs) {
        x += rhs.x;
        y += rhs.y;
        z += rhs.z;
        return *this;
    }
    Vec3f operator+(Vec3f rhs) const {
        Vec3f result = *this;
        result += rhs;
        return result;
    }
 
    Vec3f operator-() const { return {-x, -y, -z}; }
    Vec3f &operator-=(Vec3f rhs) { return *this += -rhs; }
    Vec3f operator-(Vec3f rhs) const {
        Vec3f result = *this;
        result -= rhs;
        return result;
    }
 
    Vec3f &operator*=(float rhs) {
        x *= rhs;
        y *= rhs;
        z *= rhs;
        return *this;
    }
    Vec3f operator*(float rhs) const {
        Vec3f result = *this;
        result *= rhs;
        return result;
    }
 
    Vec3f &operator/=(float rhs) {
        x /= rhs;
        y /= rhs;
        z /= rhs;
        return *this;
    }
    Vec3f operator/(float rhs) const {
        Vec3f result = *this;
        result /= rhs;
        return result;
    }
 
    float operator*(Vec3f rhs) const {
        return this->x * rhs.x + this->y * rhs.y + this->z * rhs.z;
    }
 
    float normSquared() const { return (*this) * (*this); }
 
    float norm() const {
        return std::sqrt(normSquared());
        // return std::hypot(x, y, z);  // C++17
    }
 
    Vec3f &normalize() { return *this /= norm(); }
    Vec3f normalized() const { return *this / norm(); }
 
    bool operator==(Vec3f rhs) const {
        return this->x == rhs.x && this->y == rhs.y && this->z == rhs.z;
    }
    bool operator!=(Vec3f rhs) const { return !(*this == rhs); }
};
 
inline Vec3f operator*(float lhs, Vec3f rhs) {
    return {lhs * rhs.x, lhs * rhs.y, lhs * rhs.z};
}
 
#ifndef ARDUINO
 
std::ostream &operator<<(std::ostream &os, Vec2f v);
 
std::ostream &operator<<(std::ostream &os, Vec3f v);
 
#endif
 
Print &operator<<(Print &os, Vec2f v);
 
Print &operator<<(Print &os, Vec3f v);
 
 
END_AH_NAMESPACE
 
AH_DIAGNOSTIC_POP()