yoda.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <string>
#include <vector>
#include <optional>
#include <functional>

namespace yoda {

namespace palette {
    constexpr unsigned int base03  = 0x002b36; 
    constexpr unsigned int base02  = 0x073642; 
    constexpr unsigned int base01  = 0x586e75; 
    constexpr unsigned int base00  = 0x657b83; 
    constexpr unsigned int base0   = 0x839496; 
    constexpr unsigned int base1   = 0x93a1a1; 
    constexpr unsigned int base2   = 0xeee8d5; 
    constexpr unsigned int base3   = 0xfdf6e3; 
 
    constexpr unsigned int yellow  = 0xb58900; 
    constexpr unsigned int orange  = 0xcb4b16; 
    constexpr unsigned int red     = 0xdc322f; 
    constexpr unsigned int magenta = 0xd33682; 
    constexpr unsigned int violet  = 0x6c71c4; 
    constexpr unsigned int blue    = 0x268bd2; 
    constexpr unsigned int cyan    = 0x2aa198; 
    constexpr unsigned int green   = 0x859900; 
} // namespace palette

template <typename T>
class Vec2 {
public:
    T x; 
    T y; 

    Vec2(T x = T{}, T y = T{}) : x(x), y(y) {}

    [[nodiscard]] double magnitude() const {
        return std::sqrt(static_cast<double>(x * x + y * y));
    }

    [[nodiscard]] Vec2<double> normalized() const {
        double m = magnitude();
        return {static_cast<double>(x) / m, static_cast<double>(y) / m};
    }

    [[nodiscard]] T dot(const Vec2& other) const {
        return x * other.x + y * other.y;
    }

    Vec2 operator+(const Vec2& rhs) const {
        return {x + rhs.x, y + rhs.y};
    }

    Vec2 operator*(T scalar) const {
        return {x * scalar, y * scalar};
    }
};

using Vec2d = Vec2<double>;

using Vec2i = Vec2<int>;

enum class Interpolation {
    Linear,      
    Cosine,      
    Cubic,       
    CatmullRom   
};

inline double lerp(double a, double b, double t) {
    return a + t * (b - a);
}

template <typename T>
std::vector<T> map(const std::vector<T>& values,
                   std::function<T(T)> fn) {
    std::vector<T> result;
    result.reserve(values.size());
    for (const auto& v : values) {
        result.push_back(fn(v));
    }
    return result;
}

template <typename T>
std::optional<T> find_if(const std::vector<T>& values,
                         std::function<bool(const T&)> pred) {
    for (const auto& v : values) {
        if (pred(v)) return v;
    }
    return std::nullopt;
}

class ScopedTimer {
public:
    enum class Unit {
        Seconds,      
        Milliseconds, 
        Microseconds  
    };

    explicit ScopedTimer(std::string label, Unit unit = Unit::Milliseconds);

    ~ScopedTimer();

    [[nodiscard]] const std::string& label() const { return label_; }
 
private:
    std::string label_; 
    Unit unit_;         
};
 
} // namespace yoda