vertex.h

#ifndef OE_SCENE_VERTEX_H
#define OE_SCENE_VERTEX_H
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
 
namespace oe::scene
{
    typedef uint32_t index_t;
 
    template<typename T>
    concept IsSimpleVertex = requires(T t)
    {
        {t.position} -> std::same_as<glm::vec3&>;
    };
 
    template<typename T>
    concept IsComplexVertex = requires(T t)
    {
        {t.position} -> std::same_as<glm::vec3&>;
        {t.tex_coords_0} -> std::same_as<glm::vec2&>;
        {t.normal} -> std::same_as<glm::vec3&>;
    };
 
    template<typename T>
    concept IsVertexWithTangents = requires(T t)
    {
        {t.normal} -> std::same_as<glm::vec3&>;
        {t.tangent} -> std::same_as<glm::vec3&>;
        {t.bitangent} -> std::same_as<glm::vec3&>;
    };
 
    template<typename T>
    concept IsVertexWithTexcoords = requires(T t)
    {
        {t.tex_coords_0} -> std::same_as<glm::vec2&>;
        {t.tex_coords_1} -> std::same_as<glm::vec2&>;
    };
 
    template<typename T>
    concept IsSkinnedVertex = requires(T t)
    {
        {t.bones} -> std::same_as<glm::ivec4&>;
        {t.weights} -> std::same_as<glm::vec4&>;
    };
 
    struct Vertex
    {
        glm::vec3 position = glm::vec3(0.0);
 
        glm::vec2 tex_coords_0 = glm::vec2(0.0);
 
        glm::vec2 tex_coords_1 = glm::vec2(0.0);
 
        glm::vec4 color = glm::vec4(1.0);
 
        glm::vec3 normal = glm::vec3(0.0);
 
        glm::vec3 tangent = glm::vec3(0.0);
 
        glm::vec3 bitangent = glm::vec3(0.0);
 
        bool operator==(const Vertex& other) const
        {
            return this->position == other.position;
        }
 
        friend Vertex operator*(const Vertex& lhs, const float ratio)
        {
            return Vertex({
                .position = lhs.position * ratio,
                .tex_coords_0 = lhs.tex_coords_0 * ratio,
                .tex_coords_1 = lhs.tex_coords_1 * ratio,
                .color = lhs.color * ratio,
                .normal = lhs.normal * ratio,
                .tangent = lhs.tangent * ratio,
                .bitangent = lhs.bitangent * ratio
            });
        }
 
        friend Vertex operator*(const float ratio, const Vertex& rhs)
        {
            // Use above "operator*" because 'Vertex multiplication by a ratio' is commutative
            return rhs * ratio;
        }
 
        friend Vertex operator+(const Vertex& lhs, const Vertex& rhs)
        {
            return Vertex({
                .position = lhs.position + rhs.position,
                .tex_coords_0 = lhs.tex_coords_0 + rhs.tex_coords_0,
                .tex_coords_1 = lhs.tex_coords_1 + rhs.tex_coords_1,
                .color = lhs.color + rhs.color,
                .normal = lhs.normal + rhs.normal,
                .tangent = lhs.tangent + rhs.tangent,
                .bitangent = lhs.bitangent + rhs.bitangent
            });
        }
    };
 
    struct SkinnedVertex
    {
        glm::vec3 position = glm::vec3(0.0);
 
        glm::vec2 tex_coords_0 = glm::vec2(0.0);
 
        glm::vec2 tex_coords_1 = glm::vec2(0.0);
 
        glm::vec4 color = glm::vec4(1.0);
 
        glm::vec3 normal = glm::vec3(0.0);
 
        glm::vec3 tangent = glm::vec3(0.0);
 
        glm::vec3 bitangent = glm::vec3(0.0);
 
        glm::ivec4 bones = glm::ivec4(0);
 
        glm::vec4 weights = glm::vec4(0.0);
 
        bool operator==(const Vertex& other) const
        {
            return this->position == other.position;
        }
 
        friend SkinnedVertex operator*(const SkinnedVertex& lhs, const float ratio)
        {
            return SkinnedVertex({
                .position = lhs.position * ratio,
                .tex_coords_0 = lhs.tex_coords_1 * ratio,
                .tex_coords_1 = lhs.tex_coords_1 * ratio,
                .color = lhs.color * ratio,
                .normal = lhs.normal * ratio,
                .tangent = lhs.tangent * ratio,
                .bitangent = lhs.bitangent * ratio
            });
        }
 
        friend SkinnedVertex operator*(const float ratio, const SkinnedVertex& rhs)
        {
            // Use above "operator*" because 'Vertex multiplication by a ratio' is commutative
            return rhs * ratio;
        }
 
        friend SkinnedVertex operator+(const SkinnedVertex& lhs, const SkinnedVertex& rhs)
        {
            return SkinnedVertex({
                .position = lhs.position + rhs.position,
                .tex_coords_0 = lhs.tex_coords_0 + rhs.tex_coords_0,
                .tex_coords_1 = lhs.tex_coords_1 + rhs.tex_coords_1,
                .color = lhs.color + rhs.color,
                .normal = lhs.normal + rhs.normal,
                .tangent = lhs.tangent + rhs.tangent,
                .bitangent = lhs.bitangent + rhs.bitangent
            });
        }
    };
}
 
#endif