GPUVertexFormat.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 "Common.hpp"
 
#include "GPUFormat.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Mesh/VertexDeclaration.hpp"
 
#include <tuple>
 
namespace CeresEngine {
 
    struct CE_SCRIPT_EXPORT() GPUVertexAttribute final {
        VertexElement element;
 
        CE_SCRIPT_EXPORT()
        UInt32 offset = 0;
 
    public:
        friend bool operator==(const GPUVertexAttribute& lhs, const GPUVertexAttribute& rhs);
 
        friend bool operator!=(const GPUVertexAttribute& lhs, const GPUVertexAttribute& rhs);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(element);
            CE_REFL_DATA(offset);
        }
    };
 
    struct GPUVertexInputRate final : public StructEnum<GPUVertexInputRate> {
        enum : UnderlyingType {
            Vertex,
 
            Instance,
        } raw;
        CE_STRUCT_ENUM_DECL(GPUVertexInputRate)
    };
 
    struct CE_SCRIPT_EXPORT() GPUVertexFormat final {
        SmallVector<GPUVertexAttribute, 6> attributes;
 
        CE_SCRIPT_EXPORT()
        UInt32 stride = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 inputSlot = 0;
 
        GPUVertexInputRate inputRate = GPUVertexInputRate::Vertex;
 
        CE_SCRIPT_EXPORT()
        GPUVertexFormat() noexcept = default;
 
        CE_SCRIPT_EXPORT()
        GPUVertexFormat(const GPUVertexFormat&) = default;
        GPUVertexFormat& operator=(const GPUVertexFormat&) = default;
 
        GPUVertexFormat(std::initializer_list<GPUVertexAttribute>&& aAttributesList, const UInt32 inputSlot = 0) noexcept
                : GPUVertexFormat(aAttributesList.begin(), aAttributesList.end(), inputSlot) {}
 
        template<typename BeginIterator, typename EndIterator>
        explicit GPUVertexFormat(const BeginIterator& begin, const EndIterator& end, const UInt32 inputSlot = 0) noexcept
                : attributes(begin, end), inputSlot(inputSlot) {
            UInt32 offsetSoFar = 0;
            for(GPUVertexAttribute& attribute : attributes) {
                if(attribute.offset == 0) {
                    attribute.offset = offsetSoFar;
                }
                offsetSoFar = attribute.offset + UInt32(attribute.element.getSize());
            }
        }
 
    public:
        friend bool operator==(const GPUVertexFormat& lhs, const GPUVertexFormat& rhs);
 
        friend bool operator!=(const GPUVertexFormat& lhs, const GPUVertexFormat& rhs);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(attributes);
            CE_REFL_DATA(stride);
            CE_REFL_DATA(inputSlot);
            CE_REFL_DATA(inputRate);
        }
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUVertexAttribute);
 
template<> struct std::hash<CeresEngine::GPUVertexInputRate> {
    inline size_t operator()(const CeresEngine::GPUVertexInputRate object) const noexcept { return CeresEngine::hash(object.raw); }
};
 
CE_REFLECT_HASH(CeresEngine::GPUVertexFormat);