Geometry.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/Container/Array.hpp"
#include "CeresEngine/Foundation/Container/Pair.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
 
#include "CeresEngine/Math/Matrix.hpp"
#include "CeresEngine/Math/Transform.hpp"
#include "CeresEngine/Math/Vector.hpp"
 
#include <iosfwd>
 
#if defined(far)
#undef far
#endif
#if defined(near)
#undef near
#endif
 
namespace CeresEngine::inline Math {
 
    template<typename T> struct TAABox;
    template<typename T> struct TLineSegment;
    template<typename T> struct TCapsule;
    template<typename T> struct TPlane;
    template<typename T> struct TRect;
    template<typename T> struct TSphere;
    template<typename T> struct TConvexVolume;
    template<typename T> struct TRayIntersection;
    template<typename T> struct TRay;
 
    template<typename T> struct TAABox {
        CE_SCRIPT_EXPORT()
        TVector3<T> minimum = Vector3(-T(0.5), -T(0.5), -T(0.5));
 
        CE_SCRIPT_EXPORT()
        TVector3<T> maximum = Vector3(T(0.5), T(0.5), T(0.5));
 
    public:
        enum Corner {
            FarLeftBottom = 0,
            FarLeftTop = 1,
            FarRightTop = 2,
            FarRightBottom = 3,
            NearRightBottom = 7,
            NearLeftBottom = 6,
            NearLeftTop = 5,
            NearRightTop = 4
        };
 
        CE_SCRIPT_EXPORT()
        TAABox() = default;
 
        CE_SCRIPT_EXPORT()
        TAABox(const TVector3<T>& min, const TVector3<T>& max);
 
        CE_SCRIPT_EXPORT()
        explicit TAABox(const TSphere<T>& sphere) : minimum(sphere.center - sphere.radius), maximum(sphere.center + sphere.radius) {}
 
        CE_SCRIPT_EXPORT()
        TAABox(const TAABox&) = default;
 
        ~TAABox() = default;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TAABox scale(const TVector3<T>& s) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TAABox translate(const TVector3<T>& t) const;
 
        [[nodiscard]] TVector3<T> getCorner(Corner cornerToGet) const noexcept;
 
        [[nodiscard]] Array<TVector3<T>, 8> getCorners() const noexcept;
 
        CE_SCRIPT_EXPORT()
        TAABox merge(const TAABox& rhs);
 
        CE_SCRIPT_EXPORT()
        TAABox merge(const TVector3<T>& point);
 
        CE_SCRIPT_EXPORT()
        void transform(const TMatrix4<T>& matrix);
 
        void transform(const TTransform<T>& aTransform) { transform(aTransform.getMatrix()); }
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TAABox& b2) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TSphere<T>& s) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TPlane<T>& p) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TRayIntersection<T> intersects(const TRay<T>& ray) const;
 
        CE_SCRIPT_EXPORT()
        bool intersects(const TRay<T>& ray, T& d1, T& d2) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool contains(const TVector3<T>& v) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool contains(const TVector3<T>& v, T extra) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool contains(const TAABox& other) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool contains(const TSphere<T>& s) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TVector3<T> getCenter() const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TVector3<T> getSize() const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TVector3<T> getHalfSize() const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        T getRadius() const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        T getVolume() const;
 
    public:
        friend bool operator==(const TAABox& lhs, const TAABox& rhs) { return lhs.minimum == rhs.minimum && lhs.maximum == rhs.maximum; }
 
        friend bool operator!=(const TAABox& lhs, const TAABox& rhs) { return !(lhs == rhs); }
 
        friend TAABox operator+(const TAABox& lhs, const TAABox& rhs) {
            TAABox copy = lhs;
            copy.merge(rhs);
            return copy;
        }
 
        friend TAABox& operator+=(TAABox& lhs, const TAABox& rhs) {
            lhs.merge(rhs);
            return lhs;
        }
 
        friend TAABox operator+(const TAABox& lhs, const TVector3<T>& rhs) {
            TAABox copy = lhs;
            copy.merge(rhs);
            return copy;
        }
 
        friend TAABox& operator+=(TAABox& lhs, const TVector3<T>& rhs) {
            lhs.merge(rhs);
            return lhs;
        }
 
        friend TAABox operator*(const TMatrix4<T>& lhs, TAABox rhs) {
            rhs.transform(lhs);
            return rhs;
        }
 
        friend TAABox operator*(const TTransform<T>& lhs, TAABox rhs) {
            rhs.transform(lhs);
            return rhs;
        }
 
    public:
        CE_SCRIPT_EXPORT()
        static const TAABox empty;
 
        CE_SCRIPT_EXPORT()
        static const TAABox unit;
 
        CE_SCRIPT_EXPORT()
        static const TAABox infinity;
 
        template<typename I = UInt32>
        static inline constexpr I CUBE_INDICES[] = {
            // Near
            NearLeftBottom, NearLeftTop, NearRightTop, NearLeftBottom, NearRightTop, NearRightBottom,
 
            // Far
            FarRightBottom, FarRightTop, FarLeftTop, FarRightBottom, FarLeftTop, FarLeftBottom,
 
            // Left
            FarLeftBottom, FarLeftTop, NearLeftTop, FarLeftBottom, NearLeftTop, NearLeftBottom,
 
            // Right
            NearRightBottom, NearRightTop, FarRightTop, NearRightBottom, FarRightTop, FarRightBottom,
 
            // Top
            FarLeftTop, FarRightTop, NearRightTop, FarLeftTop, NearRightTop, NearLeftTop,
 
            // Bottom
            NearLeftBottom, NearRightBottom, FarRightBottom, NearLeftBottom, FarRightBottom, FarLeftBottom};
    };
 
    extern template struct TAABox<double>;
    extern template struct TAABox<float>;
 
    template<typename T> std::ostream& operator<<(std::ostream& os, const TAABox<T>& box);
 
    extern template std::ostream& operator<<(std::ostream& os, const TAABox<double>& box);
    extern template std::ostream& operator<<(std::ostream& os, const TAABox<float>& box);
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> struct TLineSegment {
        CE_SCRIPT_EXPORT()
        TVector3<T> start = TVector3<T>(0.0);
 
        CE_SCRIPT_EXPORT()
        TVector3<T> end = TVector3<T>(0.0);
 
    public:
        CE_SCRIPT_EXPORT()
        TLineSegment() = default;
 
        CE_SCRIPT_EXPORT()
        TLineSegment(const TVector3<T>& start, const TVector3<T>& end) : start(start), end(end) {}
 
    public:
        [[nodiscard]] Pair<Array<TVector3<T>, 2>, T> getNearestPoint(const TRay<T>& ray) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        T getLength() const { return distance(start, end); }
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TVector3<T> getCenter() const { return start + (end - start) * T(0.5); }
    };
 
    extern template struct TLineSegment<double>;
    extern template struct TLineSegment<float>;
 
    template<typename T> struct TCapsule {
        CE_SCRIPT_EXPORT()
        TLineSegment<T> segment;
 
        CE_SCRIPT_EXPORT()
        T radius = T(0.0);
 
    public:
        CE_SCRIPT_EXPORT()
        TCapsule() = default;
 
        CE_SCRIPT_EXPORT()
        TCapsule(const TLineSegment<T>& segment, T radius);
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TRayIntersection<T> intersects(const TRay<T>& ray) const;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        T getHeight() const { return segment.getLength(); }
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TVector3<T> getCenter() const { return segment.getCenter(); }
    };
 
    extern template struct TCapsule<double>;
    extern template struct TCapsule<float>;
 
    template<typename T> struct TPlane {
        CE_SCRIPT_EXPORT()
        TVector3<T> normal = TVector3<T>(T(0.0));
 
        CE_SCRIPT_EXPORT()
        T distance = T(0.0);
 
    public:
        enum Side : UInt32 {
            None = 0U,
            Positive = (1U << 0U),
            Negative = (1U << 1U),
            Both = Positive | Negative
        };
 
    public:
        CE_SCRIPT_EXPORT()
        TPlane() = default;
 
        CE_SCRIPT_EXPORT()
        TPlane(const TPlane&) = default;
 
        CE_SCRIPT_EXPORT()
        TPlane(const TVector3<T>& normal, T d) : normal(normal), distance(d) {}
 
        CE_SCRIPT_EXPORT()
        explicit TPlane(const TVector4<T>& data) : normal(data.x, data.y, data.z), distance(data.w) {}
 
        CE_SCRIPT_EXPORT()
        TPlane(T a, T b, T c, T d) : normal(a, b, c), distance(d) {}
 
        CE_SCRIPT_EXPORT()
        TPlane(const TVector3<T>& normal, const TVector3<T>& point) : normal(normal), distance(dot(normal, point)) {}
 
        CE_SCRIPT_EXPORT()
        TPlane(const TVector3<T>& point0, const TVector3<T>& point1, const TVector3<T>& point2);
 
        TPlane& operator=(const TPlane& rhs) = default;
 
        CE_SCRIPT_EXPORT()
        void transform(const TMatrix4<T>& matrix);
 
        void transform(const TTransform<T>& aTransform) { transform(aTransform.getMatrix()); }
 
        [[nodiscard]] Side getSide(const TVector3<T>& point, T epsilon = 0.0) const;
 
        [[nodiscard]] Side getSide(const TAABox<T>& box) const;
 
        [[nodiscard]] Side getSide(const TSphere<T>& sphere) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT(name = "getDistanceToPoint")
        T getDistance(const TVector3<T>& point) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TVector3<T> projectVector(const TVector3<T>& v) const;
 
        CE_SCRIPT_EXPORT()
        T normalize();
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TAABox<T>& box) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TSphere<T>& sphere) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TRayIntersection<T> intersects(const TRay<T>& ray) const;
 
        bool operator==(const TPlane& rhs) const { return (rhs.distance == distance && rhs.normal == normal); }
        bool operator!=(const TPlane& rhs) const { return (rhs.distance != distance || rhs.normal != normal); }
    };
 
    extern template struct TPlane<double>;
    extern template struct TPlane<float>;
 
    template<typename T> struct TRect {
    private:
        TVector3<T> mCenter = TVector3<T>(T(0.0));
        TVector3<T> mAxisHorz = TVector3<T>(T(0.0));
        TVector3<T> mAxisVert = TVector3<T>(T(0.0));
 
        T mExtentHorz = T(0.0);
        T mExtentVert = T(0.0);
 
    public:
        TRect() = default;
 
        TRect(const TVector3<T>& center, const Array<TVector3<T>, 2>& axes, const Array<T, 2>& extents)
                : mCenter(center), mAxisHorz(axes[0]), mAxisVert(axes[1]), mExtentHorz(extents[0]), mExtentVert(extents[1]) {}
 
        [[nodiscard]] Pair<Array<TVector3<T>, 2>, T> getNearestPoint(const TRay<T>& ray) const;
 
        [[nodiscard]] Pair<TVector3<T>, T> getNearestPoint(const TVector3<T>& point) const;
 
        [[nodiscard]] TRayIntersection<T> intersects(const TRay<T>& ray) const;
 
        [[nodiscard]] const TVector3<T>& getCenter() const { return mCenter; }
 
        [[nodiscard]] const TVector3<T>& getAxisHorz() const { return mAxisHorz; }
 
        [[nodiscard]] const TVector3<T>& getAxisVert() const { return mAxisVert; }
 
        [[nodiscard]] const T& getExtentHorz() const { return mExtentHorz; }
 
        [[nodiscard]] const T& getExtentVertical() const { return mExtentVert; }
 
        friend struct std::hash<TRect>;
    };
 
    extern template struct TRect<double>;
    extern template struct TRect<float>;
 
    template<typename T> struct TSphere {
        CE_SCRIPT_EXPORT()
        T radius = T(1.0);
 
        CE_SCRIPT_EXPORT()
        TVector3<T> center = TVector3<T>(T(0.0));
 
    public:
        CE_SCRIPT_EXPORT()
        TSphere() = default;
 
        CE_SCRIPT_EXPORT()
        TSphere(const TVector3<T>& center, T radius) : radius(radius), center(center) {}
 
        CE_SCRIPT_EXPORT()
        explicit TSphere(const TAABox<T>& box) : radius(box.getRadius()), center(box.getCenter()) {}
 
    public:
        CE_SCRIPT_EXPORT()
        void merge(const TSphere& rhs);
 
        CE_SCRIPT_EXPORT()
        void merge(const TVector3<T>& point);
 
        CE_SCRIPT_EXPORT()
        void transform(const TMatrix4<T>& matrix);
 
        void transform(const TTransform<T>& aTransform) { transform(aTransform.getMatrix()); }
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool contains(const TVector3<T>& v) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool contains(const TAABox<T>& box) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TSphere& s) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TAABox<T>& box) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TPlane<T>& plane) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TRayIntersection<T> intersects(const TRay<T>& ray, bool discardInside = true) const;
 
        [[nodiscard]] T distance(const TVector3<T>& point) const;
 
        [[nodiscard]] T distance(const TSphere<T>& sphere) const;
 
    public:
        friend TSphere operator+(TSphere lhs, const TSphere& rhs) {
            lhs.merge(rhs);
            return lhs;
        }
 
        friend TSphere& operator+=(TSphere& lhs, const TSphere& rhs) {
            lhs.merge(rhs);
            return lhs;
        }
 
        friend TSphere operator+(TSphere lhs, const TVector3<T>& rhs) {
            lhs.merge(rhs);
            return lhs;
        }
 
        friend TSphere& operator+=(TSphere& lhs, const TVector3<T>& rhs) {
            lhs.merge(rhs);
            return lhs;
        }
 
        friend TSphere operator*(const TMatrix4<T>& lhs, TSphere rhs) {
            rhs.transform(lhs);
            return rhs;
        }
 
        friend TSphere operator*(const TTransform<T>& lhs, TSphere rhs) {
            rhs.transform(lhs);
            return rhs;
        }
 
    public:
        CE_SCRIPT_EXPORT()
        static const TSphere empty;
 
        CE_SCRIPT_EXPORT()
        static const TSphere unit;
 
        CE_SCRIPT_EXPORT()
        static const TSphere infinity;
    };
 
    extern template struct TSphere<double>;
    extern template struct TSphere<float>;
 
    enum class CE_SCRIPT_EXPORT() FrustumPlane {
        Left = 0,
        Right = 1,
        Top = 2,
        Bottom = 3,
        Far = 4,
        Near = 5
    };
 
    template<typename T> struct TConvexVolume {
        CE_SCRIPT_EXPORT()
        SmallVector<TPlane<T>, 10> planes;
 
    public:
        CE_SCRIPT_EXPORT()
        TConvexVolume() = default;
 
        CE_SCRIPT_EXPORT()
        explicit TConvexVolume(SmallVector<TPlane<T>, 10> planes) : planes(std::move(planes)) {}
 
        CE_SCRIPT_EXPORT()
        explicit TConvexVolume(const TMatrix4<T>& projectionMatrix, bool useNearPlane = true);
 
        CE_SCRIPT_EXPORT()
        void transform(const TMatrix4<T>& matrix);
 
        void transform(const TTransform<T>& aTransform) { transform(aTransform.getMatrix()); }
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TAABox<T>& box) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool intersects(const TSphere<T>& sphere) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TRayIntersection<T> intersects(const TRay<T>& ray) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool contains(const TVector3<T>& p, T expand = 0.0) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        const TPlane<T>& getPlane(FrustumPlane whichPlane) const;
 
    public:
        [[nodiscard]] friend TConvexVolume operator*(const TMatrix4<T>& lhs, TConvexVolume rhs) {
            rhs.transform(lhs);
            return rhs;
        }
 
        [[nodiscard]] friend TConvexVolume operator*(const TTransform<T>& lhs, TConvexVolume rhs) {
            rhs.transform(lhs);
            return rhs;
        }
    };
 
    extern template struct TConvexVolume<double>;
    extern template struct TConvexVolume<float>;
 
    template<typename T> struct TRayIntersection {
        CE_SCRIPT_EXPORT()
        bool intersects = false;
 
        CE_SCRIPT_EXPORT()
        T distance = T(0.0);
 
        CE_SCRIPT_EXPORT()
        TRayIntersection() = default;
 
        CE_SCRIPT_EXPORT()
        TRayIntersection(T distance) : intersects(true), distance(distance) {} // NOLINT
 
        explicit operator bool() const noexcept { return intersects; }
    };
 
    extern template struct TRayIntersection<double>;
    extern template struct TRayIntersection<float>;
 
    template<typename T> struct TRay {
        CE_SCRIPT_EXPORT()
        TVector3<T> origin = TVector3<T>(T(0.0));
 
        CE_SCRIPT_EXPORT()
        TVector3<T> direction = TVector3<T>(T(0.0), T(0.0), T(1.0));
 
    public:
        CE_SCRIPT_EXPORT()
        constexpr TRay() = default;
 
        CE_SCRIPT_EXPORT()
        constexpr TRay(const TVector3<T>& origin, const TVector3<T>& direction) : origin(origin), direction(direction) {}
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        constexpr TVector3<T> getPoint(T t) const { return TVector3<T>(origin + (direction * t)); }
 
        CE_SCRIPT_EXPORT()
        void transform(const TMatrix4<T>& matrix);
 
        void transform(const TTransform<T>& aTransform) { transform(aTransform.getMatrix()); }
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TRayIntersection<T> intersects(const TPlane<T>& p) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TRayIntersection<T> intersects(const TSphere<T>& s) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TRayIntersection<T> intersects(const TAABox<T>& box) const;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        TRayIntersection<T> intersects(const TVector3<T>& a, const TVector3<T>& b, const TVector3<T>& c, const TVector3<T>& normal, bool positiveSide = true,
            bool negativeSide = true) const;
 
    public:
        constexpr TVector3<T> operator[](T t) const { return getPoint(t); }
 
        friend TRay<T> operator*(const TMatrix4<T>& lhs, TRay<T> rhs) {
            rhs.transform(lhs);
            return rhs;
        }
 
        friend TRay<T> operator*(const TTransform<T>& lhs, TRay<T> rhs) {
            rhs.transform(lhs);
            return rhs;
        }
    };
 
    extern template struct TRay<double>;
    extern template struct TRay<float>;
 
    template<typename T> std::ostream& operator<<(std::ostream& os, const TRay<T>& ray);
 
    extern template std::ostream& operator<<(std::ostream&, const TRay<double>&);
    extern template std::ostream& operator<<(std::ostream&, const TRay<float>&);
 
    template<typename T> std::ostream& operator<<(std::ostream& os, const TRayIntersection<T>& intersection);
 
    extern template std::ostream& operator<<(std::ostream&, const TRayIntersection<double>&);
    extern template std::ostream& operator<<(std::ostream&, const TRayIntersection<float>&);
 
    using AABox = TAABox<double>;
    using AABoxf = TAABox<float>;
 
    using Capsule = TCapsule<double>;
    using Capsulef = TCapsule<float>;
 
    using ConvexVolume = TConvexVolume<double>;
    using ConvexVolumef = TConvexVolume<float>;
 
    using LineSegment = TLineSegment<double>;
    using LineSegmentf = TLineSegment<float>;
 
    using Plane = TPlane<double>;
    using Planef = TPlane<float>;
 
    using Ray = TRay<double>;
    using Rayf = TRay<float>;
 
    using RayIntersection = TRayIntersection<double>;
    using RayIntersectionf = TRayIntersection<float>;
 
    using Rect = TRect<double>;
    using Rectf = TRect<float>;
 
    using Sphere = TSphere<double>;
    using Spheref = TSphere<float>;
} // namespace CeresEngine::inline Math
 
template<typename T> struct std::hash<CeresEngine::TAABox<T>> {
    using Type = CeresEngine::TAABox<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.minimum, obj.maximum); }
};
 
template<typename T> struct std::hash<CeresEngine::TLineSegment<T>> {
    using Type = CeresEngine::TLineSegment<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.start, obj.end); }
};
 
template<typename T> struct std::hash<CeresEngine::TCapsule<T>> {
    using Type = CeresEngine::TCapsule<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.segment, obj.radius); }
};
 
template<typename T> struct std::hash<CeresEngine::TConvexVolume<T>> {
    using Type = CeresEngine::TConvexVolume<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.planes); }
};
 
template<typename T> struct std::hash<CeresEngine::TPlane<T>> {
    using Type = CeresEngine::TPlane<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.normal, obj.distance); }
};
 
template<typename T> struct std::hash<CeresEngine::TRect<T>> {
    using Type = CeresEngine::TRect<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.mCenter, obj.mAxisHorz, obj.mAxisVert, obj.mExtentHorz, obj.mExtentVert); }
};
 
template<typename T> struct std::hash<CeresEngine::TSphere<T>> {
    using Type = CeresEngine::TSphere<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.center, obj.radius); }
};
 
template<> struct std::hash<CeresEngine::FrustumPlane> {
    using Type = CeresEngine::FrustumPlane;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj); }
};
 
template<typename T> struct std::hash<CeresEngine::TRayIntersection<T>> {
    using Type = CeresEngine::TRayIntersection<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.distance, obj.intersects); }
};
 
template<typename T> struct std::hash<CeresEngine::TRay<T>> {
    using Type = CeresEngine::TRay<T>;
    size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.origin, obj.direction); }
};