VertexDeclaration.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 "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/StructEnum.hpp"
#include "CeresEngine/Foundation/Container/MemoryView.hpp"
#include "CeresEngine/Foundation/Container/Optional.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
#include "CeresEngine/Foundation/Container/Span.hpp"
 
#include "CeresEngine/Math/Color.hpp"
 
namespace CeresEngine {
 
    struct VertexElementSemantic final : public StructEnum<VertexElementSemantic> {
        enum : UnderlyingType {
            None,
 
            Position,
 
            Normal,
 
            TexCoord,
 
            Tangent,
 
            Bitangent,
 
            Color,
        } raw;
        CE_STRUCT_ENUM_DECL(VertexElementSemantic)
    };
 
    struct VertexElementType final : public StructEnum<VertexElementType> {
        enum : UnderlyingType {
            None,
 
            Scalar,
 
            Vector2,
 
            Vector3,
 
            Vector4,
 
            Matrix2,
 
            Matrix3,
 
            Matrix4,
        } raw;
        CE_STRUCT_ENUM_DECL(VertexElementType)
 
        
        template<typename T> static constexpr VertexElementType fromType() noexcept;
 
    public:
        [[nodiscard]] std::size_t getComponentCount() const noexcept;
 
        [[nodiscard]] bool isNone() const noexcept { return raw == None; }
 
        [[nodiscard]] bool isScalar() const noexcept { return raw == Scalar; }
 
        [[nodiscard]] bool isVector() const noexcept { return raw == Vector2 || raw == Vector3 || raw == Vector4; }
 
        [[nodiscard]] bool isMatrix() const noexcept { return raw == Matrix2 || raw == Matrix3 || raw == Matrix4; }
    };
 
    struct VertexElementComponentType final : public StructEnum<VertexElementComponentType> {
        enum : UnderlyingType {
            Float16,
 
            Float32,
 
            Float64,
 
            Int8,
 
            UInt8,
 
            Int16,
 
            UInt16,
 
            Int32,
 
            UInt32,
 
            Int64,
 
            UInt64,
 
            Boolean,
        } raw;
        CE_STRUCT_ENUM_DECL(VertexElementComponentType)
 
        
        template<typename T> static constexpr VertexElementComponentType fromType() noexcept;
 
    public:
        [[nodiscard]] std::size_t getSize() const noexcept;
    };
 
    class VertexElement final {
    public:
        VertexElementSemantic semantic;
 
        VertexElementType type = VertexElementType::Scalar;
 
        VertexElementComponentType componentType = VertexElementComponentType::Float32;
 
        UInt32 streamIndex = 0;
 
        bool normalized = false;
 
    public:
        [[nodiscard]] std::size_t getSize() const noexcept;
 
        template<typename T> [[nodiscard]] bool is() const noexcept;
 
    public:
        [[nodiscard]] String toString() const noexcept;
 
        void toString(std::ostream& stream) const noexcept;
 
        friend std::ostream& operator<<(std::ostream& stream, const VertexElement& object) {
            object.toString(stream);
            return stream;
        }
 
    public:
        friend bool operator==(const VertexElement& lhs, const VertexElement& rhs) noexcept {
            return lhs.semantic == rhs.semantic && lhs.type == rhs.type && lhs.componentType == rhs.componentType && lhs.normalized == rhs.normalized;
        }
        friend bool operator!=(const VertexElement& lhs, const VertexElement& rhs) noexcept { return !(rhs == lhs); }
    };
 
    struct VertexDeclaration final {
        SmallVector<VertexElement, 10> elements;
 
    public: // Vertex Elements
        [[nodiscard]] const VertexElement* getElement(const VertexElementSemantic& semantic, UInt32 index = 0) const noexcept;
 
        [[nodiscard]] VertexElement* getElement(const VertexElementSemantic& semantic, UInt32 index = 0) noexcept;
 
        VertexElement& addElement(const VertexElementSemantic& semantic, const VertexElementType& type,
            const VertexElementComponentType& componentType = VertexElementComponentType::Float32, bool normalized = false);
 
        template<typename T> VertexElement& addElement(const VertexElementSemantic& semantic, bool normalized = false);
 
        [[nodiscard]] bool removeElement(const VertexElementSemantic& semantic, UInt32 index = 0) noexcept;
 
    public: // Vertex Buffer
        [[nodiscard]] std::size_t getSize() const noexcept;
 
        [[nodiscard]] std::size_t getElementOffset(const VertexElementSemantic& semantic, UInt32 index = 0) const noexcept;
 
    public:
        [[nodiscard]] String toString() const noexcept;
 
        void toString(std::ostream& stream) const noexcept;
 
        friend std::ostream& operator<<(std::ostream& stream, const VertexDeclaration& object) {
            object.toString(stream);
            return stream;
        }
 
    public: // Comparison & Hashing
        friend bool operator==(const VertexDeclaration& lhs, const VertexDeclaration& rhs) noexcept;
        friend bool operator!=(const VertexDeclaration& lhs, const VertexDeclaration& rhs) noexcept;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    struct VertexBufferLayoutElement final {
        VertexElement element;
 
        UInt64 offset = 0;
 
        UInt64 stride = ~0u;
 
    public:
        [[nodiscard]] String toString() const noexcept;
 
        void toString(std::ostream& stream) const noexcept;
 
        friend std::ostream& operator<<(std::ostream& stream, const VertexBufferLayoutElement& object) {
            object.toString(stream);
            return stream;
        }
 
    public: // Comparison & Hashing
        friend bool operator==(const VertexBufferLayoutElement& lhs, const VertexBufferLayoutElement& rhs) noexcept;
        friend bool operator!=(const VertexBufferLayoutElement& lhs, const VertexBufferLayoutElement& rhs) noexcept;
    };
 
    struct VertexBufferLayout final {
        SmallVector<VertexBufferLayoutElement, 10> elements;
 
        UInt64 length;
 
    public:
        [[nodiscard]] const VertexBufferLayoutElement* getElement(const VertexElementSemantic& semantic, UInt32 index = 0) const noexcept;
 
        [[nodiscard]] VertexBufferLayoutElement* getElement(const VertexElementSemantic& semantic, UInt32 index = 0) noexcept;
 
        template<typename T>
        [[nodiscard]] StridedMemoryView<T> getElementView(const MemoryView<Byte>& data, const VertexElementSemantic& semantic, const UInt32 index = 0) {
            CE_ASSERT(data.size() >= getSize() * length);
 
            const VertexBufferLayoutElement* element = getElement(semantic, index);
            if(element == nullptr) {
                return nullptr;
            }
 
            CE_ASSERT(element->element.is<T>());
            return make_strided_memory_view<T>(data, element->offset, element->stride);
        }
 
        template<typename T>
        [[nodiscard]] StridedMemoryView<const T> getElementView(const MemoryView<const Byte>& data, const VertexElementSemantic& semantic, const UInt32 index = 0) {
            // NOTE: It's safe to perform the const_cast here as it's later
            // converted back to a `const T` view.
            return getElementView<T>(data.as<Byte>(), semantic, index).template as<const T>();
        }
 
        void validate();
 
    public: // Buffer sizes
        void resize(UInt64 newVertexCount);
 
        void offsetBy(const Int64 offset) const;
 
        [[nodiscard]] std::size_t getSize() const noexcept;
 
        [[nodiscard]] std::size_t getVertexSize() const noexcept;
 
    public: // Standard layouts
        static VertexBufferLayout separated(const Span<const VertexElement>& elements, UInt64 vertexCount);
 
        static VertexBufferLayout separated(const VertexDeclaration& declaration, const UInt64 vertexCount) {
            return separated(declaration.elements, vertexCount);
        }
 
        static VertexBufferLayout interleaved(const Span<const VertexElement>& elements, UInt64 vertexCount);
 
        static VertexBufferLayout interleaved(const VertexDeclaration& declaration, const UInt64 vertexCount) {
            return interleaved(declaration.elements, vertexCount);
        }
 
    public:
        [[nodiscard]] String toString() const noexcept;
 
        void toString(std::ostream& stream) const noexcept;
 
        friend std::ostream& operator<<(std::ostream& stream, const VertexBufferLayout& object) {
            object.toString(stream);
            return stream;
        }
 
    public: // Comparison & Hashing
        friend bool operator==(const VertexBufferLayout& lhs, const VertexBufferLayout& rhs) noexcept;
        friend bool operator!=(const VertexBufferLayout& lhs, const VertexBufferLayout& rhs) noexcept;
    };
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> struct VertexElementTypeTrait { static inline constexpr VertexElementType value = VertexElementType::Scalar; };
    template<typename T> struct VertexElementTypeTrait<TVector2<T>> { static inline constexpr VertexElementType value = VertexElementType::Vector2; };
    template<typename T> struct VertexElementTypeTrait<TVector3<T>> { static inline constexpr VertexElementType value = VertexElementType::Vector3; };
    template<typename T> struct VertexElementTypeTrait<TVector4<T>> { static inline constexpr VertexElementType value = VertexElementType::Vector4; };
    template<typename T> struct VertexElementTypeTrait<TMatrix2<T>> { static inline constexpr VertexElementType value = VertexElementType::Matrix2; };
    template<typename T> struct VertexElementTypeTrait<TMatrix3<T>> { static inline constexpr VertexElementType value = VertexElementType::Matrix3; };
    template<typename T> struct VertexElementTypeTrait<TMatrix4<T>> { static inline constexpr VertexElementType value = VertexElementType::Matrix4; };
    template<typename T> struct VertexElementTypeTrait<TColor<T>> { static inline constexpr VertexElementType value = VertexElementType::Vector4; };
 
    template<typename T> constexpr VertexElementType VertexElementType::fromType() noexcept { return VertexElementTypeTrait<T>::value; }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> struct VertexElementComponentTypeTrait;
    template<> struct VertexElementComponentTypeTrait<float> {
        static inline constexpr VertexElementComponentType value = VertexElementComponentType::Float32;
    };
    template<> struct VertexElementComponentTypeTrait<double> {
        static inline constexpr VertexElementComponentType value = VertexElementComponentType::Float64;
    };
    template<> struct VertexElementComponentTypeTrait<Int8> { static inline constexpr VertexElementComponentType value = VertexElementComponentType::Int8; };
    template<> struct VertexElementComponentTypeTrait<UInt8> { static inline constexpr VertexElementComponentType value = VertexElementComponentType::UInt8; };
    template<> struct VertexElementComponentTypeTrait<Int16> { static inline constexpr VertexElementComponentType value = VertexElementComponentType::Int16; };
    template<> struct VertexElementComponentTypeTrait<UInt16> {
        static inline constexpr VertexElementComponentType value = VertexElementComponentType::UInt16;
    };
    template<> struct VertexElementComponentTypeTrait<Int32> { static inline constexpr VertexElementComponentType value = VertexElementComponentType::Int32; };
    template<> struct VertexElementComponentTypeTrait<UInt32> {
        static inline constexpr VertexElementComponentType value = VertexElementComponentType::UInt32;
    };
    template<> struct VertexElementComponentTypeTrait<Int64> { static inline constexpr VertexElementComponentType value = VertexElementComponentType::Int64; };
    template<> struct VertexElementComponentTypeTrait<UInt64> {
        static inline constexpr VertexElementComponentType value = VertexElementComponentType::UInt64;
    };
    template<> struct VertexElementComponentTypeTrait<bool> { static inline constexpr VertexElementComponentType value = VertexElementComponentType::Boolean; };
 
    template<typename T> constexpr VertexElementComponentType VertexElementComponentType::fromType() noexcept {
        return VertexElementComponentTypeTrait<T>::value;
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> struct VertexElementTrait {
        static inline constexpr VertexElementType type = VertexElementType::fromType<T>();
        static inline constexpr VertexElementComponentType componentType = VertexElementComponentType::fromType<T>();
    };
 
    template<size_t D, typename T> struct VertexElementTrait<TVector<D, T>> {
        static inline constexpr VertexElementType type = VertexElementType::fromType<TVector<D, T>>();
        static inline constexpr VertexElementComponentType componentType = VertexElementComponentType::fromType<T>();
    };
 
    template<size_t C, size_t R, typename T> struct VertexElementTrait<TMatrix<C, R, T>> {
        static inline constexpr VertexElementType type = VertexElementType::fromType<TMatrix<C, R, T>>();
        static inline constexpr VertexElementComponentType componentType = VertexElementComponentType::fromType<T>();
    };
 
    template<typename T> struct VertexElementTrait<TColor<T>> {
        static inline constexpr VertexElementType type = VertexElementType::fromType<TColor<T>>();
        static inline constexpr VertexElementComponentType componentType = VertexElementComponentType::fromType<T>();
    };
 
    template<typename T> bool VertexElement::is() const noexcept {
        return type == VertexElementTrait<T>::type && componentType == VertexElementTrait<T>::componentType;
    }
 
    template<typename T> VertexElement& VertexDeclaration::addElement(const VertexElementSemantic& semantic, const bool normalized) {
        return addElement(semantic, VertexElementTrait<T>::type, VertexElementTrait<T>::componentType, normalized);
    }
 
} // namespace CeresEngine
 
template<> struct std::hash<CeresEngine::VertexElementSemantic> {
    inline size_t operator()(const CeresEngine::VertexElementSemantic object) const noexcept { return CeresEngine::hash(object.raw); }
};
 
template<> struct std::hash<CeresEngine::VertexElementType> {
    inline size_t operator()(const CeresEngine::VertexElementType object) const noexcept { return CeresEngine::hash(object.raw); }
};
 
template<> struct std::hash<CeresEngine::VertexElementComponentType> {
    inline size_t operator()(const CeresEngine::VertexElementComponentType object) const noexcept { return CeresEngine::hash(object.raw); }
};
 
template<> struct std::hash<CeresEngine::VertexElement> {
    inline size_t operator()(const CeresEngine::VertexElement& object) const noexcept {
        return CeresEngine::hash(object.semantic, object.type, object.componentType, object.normalized);
    }
};
 
template<> struct std::hash<CeresEngine::VertexDeclaration> {
    inline size_t operator()(const CeresEngine::VertexDeclaration& object) const noexcept { return CeresEngine::hash(object.elements); }
};