GPUVertex.hpp

/*
** ETIB PROJECT, 2025
** evan
** File description:
** GPUVertex
*/
 
#ifndef GPUVERTEX_HPP_
#define GPUVERTEX_HPP_
 
#include "evan/EvanPlatform.hpp"
 
#include <utility/graphic/vertex.hpp>
 
#include <glm/glm.hpp>
 
namespace evan
{
    struct GPUInstance {
        glm::mat4 model = glm::mat4(1.0f);
    };
 
    struct GPUVertex {
        glm::vec3 pos;      
        glm::vec3 color;    
 
        glm::vec2 texCoord;
 
        static VkVertexInputBindingDescription getBindingDescription()
        {
            VkVertexInputBindingDescription bindingDescription {};
            bindingDescription.binding   = 0;
            bindingDescription.stride    = sizeof(GPUVertex);
            bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
 
            return bindingDescription;
        }
 
        static std::array<VkVertexInputAttributeDescription, 3>
            getAttributeDescriptions()
        {
            std::array<VkVertexInputAttributeDescription, 3>
                attributeDescriptions {};
 
            attributeDescriptions[0].binding  = 0;
            attributeDescriptions[0].location = 0;
            attributeDescriptions[0].format   = VK_FORMAT_R32G32B32_SFLOAT;
            attributeDescriptions[0].offset   = offsetof(GPUVertex, pos);
 
            attributeDescriptions[1].binding  = 0;
            attributeDescriptions[1].location = 1;
            attributeDescriptions[1].format   = VK_FORMAT_R32G32B32_SFLOAT;
            attributeDescriptions[1].offset   = offsetof(GPUVertex, color);
 
            attributeDescriptions[2].binding  = 0;
            attributeDescriptions[2].location = 2;
            attributeDescriptions[2].format   = VK_FORMAT_R32G32_SFLOAT;
            attributeDescriptions[2].offset   = offsetof(GPUVertex, texCoord);
 
            return attributeDescriptions;
        }
 
        static VkVertexInputBindingDescription getInstanceBindingDescription()
        {
            VkVertexInputBindingDescription bindingDescription {};
            bindingDescription.binding   = 1;
            bindingDescription.stride    = sizeof(GPUInstance);
            bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
 
            return bindingDescription;
        }
 
        static std::array<VkVertexInputAttributeDescription, 4>
            getInstanceAttributeDescriptions()
        {
            std::array<VkVertexInputAttributeDescription, 4>
                attributeDescriptions {};
 
            for (std::size_t i = 0; i < 4; ++i) {
                attributeDescriptions[i].binding  = 1;
                attributeDescriptions[i].location = static_cast<uint32_t>(3 + i);
                attributeDescriptions[i].format = VK_FORMAT_R32G32B32A32_SFLOAT;
                attributeDescriptions[i].offset =
                    static_cast<uint32_t>(i * sizeof(glm::vec4));
            }
 
            return attributeDescriptions;
        }
 
        bool operator==(const GPUVertex &other) const
        {
            return pos == other.pos && color == other.color
                && texCoord == other.texCoord;
        }
 
        static GPUVertex
            createFromVertex(const utility::graphic::VertexF &vertex)
        {
            auto color32Bit = vertex.getColor();
            auto red        = color32Bit.getRed() / 255.0f;
            auto green      = color32Bit.getGreen() / 255.0f;
            auto blue       = color32Bit.getBlue() / 255.0f;
 
            return GPUVertex { glm::vec3(vertex.getPosition().x,
                                         vertex.getPosition().y,
                                         vertex.getPosition().z),
                               glm::vec3(red, green, blue),
                               glm::vec2(vertex.getTextureCoordinates().x,
                                         vertex.getTextureCoordinates().y) };
        }
    };
}    // namespace evan
 
#endif /* !GPUVERTEX_HPP_ */