vertex.h

#ifndef OE_SCENE_VERTEX_H
#define OE_SCENE_VERTEX_H
 
#include "../common.h"
 
#include <vector>
#include <map>
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
 
namespace oe::scene
{
    typedef uint32_t index_t;
 
    template<typename T>
    concept SimpleVertex = requires(T t)
    {
        {t.position} -> std::same_as<glm::vec3&>;
    };
 
    template<typename T>
    concept ComplexVertex = requires(T t)
    {
        {t.position} -> std::same_as<glm::vec3&>;
        {t.tex_coords} -> std::same_as<glm::vec2&>;
        {t.normal} -> std::same_as<glm::vec3&>;
    };
 
    struct Vertex
    {
        glm::vec3 position = glm::vec3(0.0);
 
        glm::vec2 tex_coords = glm::vec2(0.0);
 
        glm::vec2 lm_coords = glm::vec2(0.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 = lhs.tex_coords * ratio,
                .lm_coords = lhs.lm_coords * ratio,
                .normal = lhs.normal * ratio,
                .tangent = lhs.tangent * ratio,
                .bitangent = lhs.bitangent * ratio
            });
        }
 
        friend Vertex operator*(const float ratio, const Vertex& rhs)
        {
            // Same as above (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 = lhs.tex_coords + rhs.tex_coords,
                .lm_coords = lhs.lm_coords + rhs.lm_coords,
                .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 = glm::vec2(0.0);
 
        glm::vec2 lm_coords = glm::vec2(0.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 = lhs.tex_coords * ratio,
                .lm_coords = lhs.lm_coords * ratio,
                .normal = lhs.normal * ratio,
                .tangent = lhs.tangent * ratio,
                .bitangent = lhs.bitangent * ratio
            });
        }
 
        friend SkinnedVertex operator*(const float ratio, const SkinnedVertex& rhs)
        {
            // Same as above (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 = lhs.tex_coords + rhs.tex_coords,
                .lm_coords = lhs.lm_coords + rhs.lm_coords,
                .normal = lhs.normal + rhs.normal,
                .tangent = lhs.tangent + rhs.tangent,
                .bitangent = lhs.bitangent + rhs.bitangent
            });
        }
    };
}
 
#endif