renderablemesh.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
 
// Local includes
#include "mesh.h"
#include "materialinstance.h"
#include "nap/signalslot.h"
 
namespace nap
{
    // Forward Declares
    class RenderService;
 
    class NAPAPI RenderableMesh final
    {
        friend class RenderService;
    public:
        RenderableMesh() = default;
 
        // Copy constructor
        RenderableMesh(const RenderableMesh& rhs);
 
        // Copy assignment operator
        RenderableMesh& operator=(const RenderableMesh& rhs);
 
        // Object is similar when sharing mesh / material combination
        bool operator==(const RenderableMesh& rhs) const;
 
        bool isValid() const                                                    { return mMesh != nullptr; }
 
        IMesh& getMesh()                                                        { return *mMesh; }
 
        const IMesh& getMesh() const                                            { return *mMesh; }
 
        MaterialInstance& getMaterialInstance()                                 { return *mMaterialInstance; }
 
        const MaterialInstance& getMaterialInstance() const                     { return *mMaterialInstance; }
 
        const std::vector<VkBuffer>& getVertexBuffers();
 
        const std::vector<VkDeviceSize>& getVertexBufferOffsets() const         { return mVertexBufferOffsets; }
 
        int getVertexBufferBindingIndex(const std::string& meshVertexAttributeID) const;
 
    protected:
        RenderableMesh(IMesh& mesh, MaterialInstance& materialInstance);
 
    private:
        void onVertexBufferDataChanged();
 
    private:
        MaterialInstance*           mMaterialInstance = nullptr;    
        IMesh*                      mMesh = nullptr;                
        std::vector<VkBuffer>       mVertexBuffers;
        std::vector<VkDeviceSize>   mVertexBufferOffsets;
        bool                        mVertexBuffersDirty = true;
        nap::Slot<>                 mVertexBufferDataChangedSlot = { [&]() { onVertexBufferDataChanged(); } };
    };
}
 
 
// hash
 
namespace std
{
    template<>
    struct hash<nap::RenderableMesh>
    {
        size_t operator()(const nap::RenderableMesh& key) const
        {
            assert(key.isValid());
            size_t mesh_hash = hash<size_t>{}((size_t)&key.getMesh());
            size_t mate_hash = hash<size_t>{}((size_t)&key.getMaterialInstance());
            return mesh_hash ^ mate_hash;
        }
    };
}