point.h

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <type_traits>
#include <promeki/core/namespace.h>
#include <promeki/core/string.h>
#include <promeki/core/stringlist.h>
#include <promeki/core/error.h>
#include <promeki/core/logger.h>
#include <promeki/core/array.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T, size_t NumValues> class Point {
        public:
               static Error fromString(const String &val, Point &d) {
                        StringList parts = val.split(",");
                        if(parts.size() != NumValues) return Error::Invalid;
                        for(size_t i = 0; i < NumValues; ++i) {
                                Error err;
                                d[i] = static_cast<T>(parts[i].trim().toDouble(&err));
                                if(err.isError()) return Error::Invalid;
                        }
                        return Error::Ok;
                }
 
                static Point fromString(const String &str, Error *err = nullptr) {
                        Array<T, NumValues> d;
                        Error e = fromString(str, d);
                        if(err != nullptr) *err = e;
                        return e.isOk() ? d : Point();
                }
 
                Point() : d{} {}
 
                Point(const Array<T, NumValues> &val) : d(val) {}
 
                template<typename... Args> Point(Args... args) : d{static_cast<T>(args)...} {}
 
                Point(const String &str) : d(fromString(str)) { }
 
                virtual ~Point() { }
 
                operator String() const {
                        return toString();
                }
 
                operator const Array<T, NumValues>&() const {
                        return d;
                }
 
                bool operator==(const Array<T, NumValues> &val) const {
                        return d == val;
                }
 
                bool operator!=(const Array<T, NumValues> &val) const {
                        return d != val;
                }
 
                Point &operator+=(const Array<T, NumValues> &val) {
                        d += val;
                        return *this;
                }
 
                Point &operator-=(const Array<T, NumValues> &val) {
                        d -= val;
                        return *this;
                }
 
                Point &operator*=(const Array<T, NumValues> &val) {
                        d *= val;
                        return *this;
                }
 
                Point &operator/=(const Array<T, NumValues> &val) {
                        d /= val;
                        return *this;
                }
                
                template<size_t N = NumValues, typename std::enable_if_t<N >= 1, int> = 0> const T &x() const {
                        return d[0];
                }
 
                template<size_t N = NumValues, typename std::enable_if_t<N >= 1, int> = 0> T &x() {
                        return d[0];
                }
 
                template<size_t N = NumValues, typename std::enable_if_t<N >= 1, int> = 0> void setX(const T &val) {
                        d[0] = val;
                        return;
                }
 
                template<size_t N = NumValues, typename std::enable_if_t<N >= 2, int> = 0> const T &y() const {
                        return d[1];
                }
 
                template<size_t N = NumValues, typename std::enable_if_t<N >= 2, int> = 0> T &y() {
                        return d[1];
                }
 
                template<size_t N = NumValues, typename std::enable_if_t<N >= 2, int> = 0> void setY(const T &val) {
                        d[1] = val;
                        return;
                }
 
                template<size_t N = NumValues, typename std::enable_if_t<N >= 3, int> = 0> const T &z() const {
                        return d[2];
                }
 
                template<size_t N = NumValues, typename std::enable_if_t<N >= 3, int> = 0> T &z() {
                        return d[2];
                }
 
                template<size_t N = NumValues, typename std::enable_if_t<N >= 3, int> = 0> void setZ(const T &val) {
                        d[2] = val;
                        return;
                }
 
                String toString() const {
                        String result;
                        for(size_t i = 0; i < NumValues; ++i) {
                                if(i > 0) result += ", ";
                                if constexpr (std::is_floating_point_v<T>) {
                                        result += String::number(static_cast<double>(d[i]));
                                } else {
                                        result += String::dec(static_cast<int64_t>(d[i]));
                                }
                        }
                        return result;
                }
               
                template <typename U> double distanceTo(const Point<U, NumValues>& other) const {
                        double sum = 0;
                        for(size_t i = 0; i < NumValues; ++i) {
                                double diff = static_cast<double>(d[i]) - static_cast<double>(other.d[i]);
                                sum += diff * diff;
                        }
                        return std::sqrt(sum);
                }
                
                Point<T, NumValues> lerp(const Point<T, NumValues> &other, double t) const { return d.lerp(other, t); }
 
                template <typename U> Point<T, NumValues> clamp(
                                const Point<U, NumValues>& minVal,
                                const Point<U, NumValues>& maxVal) const {
                        Point<T, NumValues> result;
                        for(size_t i = 0; i < NumValues; ++i) {
                                T val = d[i];
                                if (val < static_cast<T>(minVal.d[i])) val = static_cast<T>(minVal.d[i]);
                                if (val > static_cast<T>(maxVal.d[i])) val = static_cast<T>(maxVal.d[i]);
                                result.d[i] = val;
                        }
                        return result;
                }
 
                bool isWithinBounds(const Point<T, NumValues>& min, const Point<T, NumValues>& max) const {
                        for (size_t i = 0; i < NumValues; ++i) {
                                if (d[i] < min.d[i] || d[i] > max.d[i]) {
                                        return false;
                                }
                        }
                        return true;
                }
                
                friend Point operator+(const Array<T, NumValues> &lh, const Array<T, NumValues> &rh) {
                        return Point(lh + rh);
                }
 
                friend Point operator-(const Array<T, NumValues> &lh, const Array<T, NumValues> &rh) {
                        return Point(lh - rh);
                }
 
                friend Point operator*(const Array<T, NumValues> &lh, const Array<T, NumValues> &rh) {
                        return Point(lh * rh);
                }
 
                friend Point operator/(const Array<T, NumValues> &lh, const Array<T, NumValues> &rh) {
                        return Point(lh / rh);
                }
 
        private:
                Array<T, NumValues>     d;
};
 
using Point2Di32 = Point<int32_t, 2>;
using Point2Df = Point<float, 2>;
using Point2Dd = Point<double, 2>;
using Point3Di32 = Point<int32_t, 3>;
using Point3Df = Point<float, 3>;
using Point3Dd = Point<double, 3>;
using Point4Di32 = Point<int32_t, 4>;
using Point4Df = Point<float, 4>;
using Point4Dd = Point<double, 4>;
 
PROMEKI_NAMESPACE_END