vertex.hpp

/*
** ETIB PROJECT, 2025
** evan
** File description:
** Vertex
*/
 
#pragma once
 
#include <cmath>
#include <ostream>
#include <type_traits>
 
#include "utility/graphic/color.hpp"
#include "utility/graphic/position.hpp"
 
#include "utility/math/vector.hpp"
 
namespace utility::graphic
{
 
    template<typename Type>
    concept CanBeVectorComponent =
        math::CanBeVectorComponent<Type> && CanBePositionComponent<Type>;
 
    template<CanBeVectorComponent VectorComponent> class Vertex
    {
        private:
        Position<VectorComponent>
            _position;    
        math::Vector<VectorComponent, 3> _normal;    
        math::Vector<VectorComponent, 2>
            _textureCoordinates;    
        Color32Bit _color;          
 
        public:
        Vertex(void)
            : _position {}
            , _normal {}
            , _textureCoordinates {}
            , _color {}
        {
        }
 
        Vertex(const Position<VectorComponent> &position,
               const math::Vector<VectorComponent, 3> &normal,
               const math::Vector<VectorComponent, 2> &textureCoordinates,
               const Color32Bit &color)
            : _position(position)
            , _normal(normal)
            , _textureCoordinates(textureCoordinates)
            , _color(color)
        {
        }
 
        void setPosition(const Position<VectorComponent> &position)
        {
            _position = position;
        }
 
        Position<VectorComponent> getPosition(void) const
        {
            return _position;
        }
 
        void setNormal(const math::Vector<VectorComponent, 3> &normal)
        {
            _normal = normal;
        }
 
        math::Vector<VectorComponent, 3> getNormal(void) const
        {
            return _normal;
        }
 
        void setTextureCoordinates(
            const math::Vector<VectorComponent, 2> &textureCoordinates)
        {
            _textureCoordinates = textureCoordinates;
        }
 
        math::Vector<VectorComponent, 2> getTextureCoordinates(void) const
        {
            return _textureCoordinates;
        }
 
        void setColor(const Color32Bit &color)
        {
            _color = color;
        }
 
        Color32Bit getColor(void) const
        {
            return _color;
        }
 
        Vertex &setAttributes(
            const Position<VectorComponent> &position,
            const math::Vector<VectorComponent, 3> &normal,
            const math::Vector<VectorComponent, 2> &textureCoordinates,
            const Color32Bit &color)
        {
            _position           = position;
            _normal             = normal;
            _textureCoordinates = textureCoordinates;
            _color              = color;
            return *this;
        }
 
        bool hasUnitNormal(VectorComponent epsilon = VectorComponent {
                               1e-5 }) const
        {
            const VectorComponent normSquared = _normal[0] * _normal[0]
                + _normal[1] * _normal[1] + _normal[2] * _normal[2];
            return std::abs(normSquared - VectorComponent { 1 }) <= epsilon;
        }
 
        bool operator==(const Vertex &other) const
        {
            return _position == other._position && _normal == other._normal
                && _textureCoordinates == other._textureCoordinates
                && _color == other._color;
        }
 
        bool operator!=(const Vertex &other) const
        {
            return !(*this == other);
        }
    };
 
    using VertexF = Vertex<float>;
 
    using VertexD = Vertex<double>;
 
    std::ostream &operator<<(std::ostream &stream, const VertexF &vertex);
 
    std::ostream &operator<<(std::ostream &stream, const VertexD &vertex);
 
}    // namespace utility::graphic