vertexattribute.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#include <utility/dllexport.h>
#include <nap/resource.h>
#include <glm/glm.hpp>
#include <nap/numeric.h>
 
#include "vulkan/vulkan_core.h"
 
namespace nap
{
    class NAPAPI BaseVertexAttribute : public Resource
    {
        RTTI_ENABLE(Resource)
    public:
        BaseVertexAttribute(const nap::rtti::TypeInfo& elementType);
        
        virtual void* getRawData() = 0;
 
        virtual VkFormat getFormat() const = 0;
        
        virtual int getCount() const = 0;
 
        virtual size_t getCapacity() const = 0;
 
        virtual void reserve(size_t numElements) = 0;
 
        const nap::rtti::TypeInfo& getElementType() const               { return mElementType; }
 
        std::string         mAttributeID;       
        rtti::TypeInfo      mElementType;       
    };
 
 
 
    template<typename ELEMENTTYPE>
    class VertexAttribute : public BaseVertexAttribute
    {
        RTTI_ENABLE(BaseVertexAttribute)
    public:
 
        VertexAttribute() : BaseVertexAttribute(RTTI_OF(ELEMENTTYPE))   { }
 
        virtual void reserve(size_t numElements) override               { mData.reserve(numElements); }
 
        virtual size_t getCapacity() const override                     { return mData.capacity(); }
 
        void resize(size_t numElements)                                 { mData.resize(numElements); }
 
        void clear()                                                    { mData.clear(); }
 
        const std::vector<ELEMENTTYPE>& getData() const                 { return mData; }
 
        std::vector<ELEMENTTYPE>& getData()                             { return mData; }
 
        void addData(const ELEMENTTYPE& element)                        { mData.emplace_back(element); }
 
        void addData(const ELEMENTTYPE&& element) noexcept              { mData.emplace_back(std::move(element)); }
 
        void addData(const ELEMENTTYPE* elements, int numElements);
 
        void setData(const std::vector<ELEMENTTYPE>& values)            { setData(&(values.front()), values.size()); }
 
        void setData(const ELEMENTTYPE* elements, int numElements);
 
        virtual VkFormat getFormat() const override;
 
        virtual int getCount() const override                           { return static_cast<int>(mData.size()); }
 
        ELEMENTTYPE& operator[](std::size_t index)                      { return mData[index]; }
        
        const ELEMENTTYPE& operator[](std::size_t index) const          { return mData[index]; }
 
        std::vector<ELEMENTTYPE>    mData;                              
 
    protected:
        virtual void* getRawData() override;
    };
 
 
    // Type definitions for all supported vertex attribute types
 
    using UIntVertexAttribute   = VertexAttribute<uint>;
    using IntVertexAttribute    = VertexAttribute<int>;
    using FloatVertexAttribute  = VertexAttribute<float>;
    using Vec2VertexAttribute   = VertexAttribute<glm::vec2>;
    using Vec3VertexAttribute   = VertexAttribute<glm::vec3>;
    using Vec4VertexAttribute   = VertexAttribute<glm::vec4>;
    using IVec4VertexAttribute  = VertexAttribute<glm::ivec4>;
    
 
    // Template Definitions
 
    template<typename ELEMENTTYPE>
    void nap::VertexAttribute<ELEMENTTYPE>::setData(const ELEMENTTYPE* elements, int numElements)
    {
        mData.resize(numElements);
        memcpy(mData.data(), elements, numElements * sizeof(ELEMENTTYPE));
    }
 
    template<typename ELEMENTTYPE>
    void nap::VertexAttribute<ELEMENTTYPE>::addData(const ELEMENTTYPE* elements, int numElements)
    {
        int cur_num_elements = mData.size();
        mData.resize(cur_num_elements + numElements);
        memcpy((void*)&mData[cur_num_elements], elements, numElements * sizeof(ELEMENTTYPE));
    }
 
    template<typename ELEMENTTYPE>
    void* nap::VertexAttribute<ELEMENTTYPE>::getRawData()
    {
        return static_cast<void*>(mData.data());
    }
 
 
    // Forward declarations of templated functions
 
    template<>
    NAPAPI VkFormat UIntVertexAttribute::getFormat() const;
 
    template<>
    NAPAPI VkFormat IntVertexAttribute::getFormat() const;
 
    template<>
    NAPAPI VkFormat FloatVertexAttribute::getFormat() const;
 
    template<>
    NAPAPI VkFormat Vec2VertexAttribute::getFormat() const;
 
    template<>
    NAPAPI VkFormat Vec3VertexAttribute::getFormat() const;
 
    template<>
    NAPAPI VkFormat Vec4VertexAttribute::getFormat() const;
 
    template<>
    NAPAPI VkFormat IVec4VertexAttribute::getFormat() const;
} // nap