VertexLayout.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 "VertexDeclaration.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Container/MemoryView.hpp"
 
namespace CeresEngine {
 
    struct VertexLayoutElement {
        VertexElement element;
 
        size_t offset = 0;
 
        size_t stride = 0;
 
        [[nodiscard]] size_t operator[](const size_t index) const { return offset + stride * index; }
 
        template<typename T> StridedMemoryView<const T> view(const MemoryView<const Byte> view, const size_t count = 0) const {
            CE_ASSERT(element.is<T>());
            const MemoryView<const Byte>& slice = view.slice(offset, stride * count);
            return StridedMemoryView<const T>(reinterpret_cast<const T*>(slice.data()), slice.size() / stride, stride);
        }
 
        template<typename T> StridedMemoryView<T> view(const MemoryView<Byte> view, const size_t count = 0) const {
            CE_ASSERT(element.is<T>());
            const MemoryView<Byte>& slice = view.slice(offset, stride * count);
            return StridedMemoryView<T>(reinterpret_cast<T*>(slice.data()), slice.size() / stride, stride);
        }
    };
 
    struct VertexLayout {
        Vector<VertexLayoutElement> layoutElements;
 
        void addElement(VertexElement element, const size_t offset, size_t stride = ~0ul) {
            if(stride == ~0ul) {
                stride = element.getSize();
            }
 
            layoutElements.emplace_back(VertexLayoutElement{
                .element = element,
                .offset = offset,
                .stride = stride,
            });
        }
 
        static VertexLayout interleaved(const VertexDeclaration& declaration) {
            const std::size_t stride = declaration.getSize();
            std::size_t offset = 0;
 
            VertexLayout layout;
            for(const VertexElement& element : declaration.elements) {
                layout.addElement(element, offset, stride);
                offset += element.getSize();
            }
 
            return layout;
        }
 
        static VertexLayout separated(const VertexDeclaration& declaration, const std::size_t vertexCount) {
            std::size_t offset = 0;
 
            VertexLayout layout;
            for(const VertexElement& element : declaration.elements) {
                const std::size_t length = element.getSize() * vertexCount;
                layout.addElement(element, offset, element.getSize());
                offset += length;
            }
 
            return layout;
        }
    };
 
} // namespace CeresEngine