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)                               { this->copy(rhs); }
 
        // Copy assignment operator
        RenderableMesh& operator=(const RenderableMesh& rhs)                    { this->copy(rhs); return *this; }
 
        // Move constructor
        RenderableMesh(RenderableMesh&& other)                                  { this->move(std::move(other)); }
 
        // Move assignment operator
        RenderableMesh& operator=(RenderableMesh&& other)                       { this->move(std::move(other)); return *this; }
 
        // Object is similar when sharing mesh / material combination
        bool operator==(const RenderableMesh& rhs) const                        { return mMaterialInstance == rhs.mMaterialInstance && mMesh == rhs.mMesh; }
 
        // Object is different when not sharing mesh / material combination
        bool operator!=(const RenderableMesh& rhs) const                        { return !(rhs == *this); }
 
        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()                                        { mVertexBuffersDirty = true; }
        void move(RenderableMesh&& other);
        void copy(const RenderableMesh& rhs);
 
    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;
        }
    };
}