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();
        
        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;
 
        std::string         mAttributeID;       
    };
 
 
 
    template<typename ELEMENTTYPE>
    class VertexAttribute : public BaseVertexAttribute
    {
        RTTI_ENABLE(BaseVertexAttribute)
    public:
 
        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* 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>;
 
 
    // 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;
 
} // nap