samplerinstance.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 "sampler.h"
 
namespace nap
{
    // Called when the bound sampler resource changes
    using SamplerChangedCallback = std::function<void(SamplerInstance&)>;
 
    class NAPAPI SamplerInstance
    {
        RTTI_ENABLE()
    public:
        SamplerInstance(RenderService& renderService, const SamplerDeclaration& declaration, const Sampler* sampler, const SamplerChangedCallback& samplerChangedCallback);
        virtual ~SamplerInstance();
 
        bool init(utility::ErrorState& errorState);
 
        const SamplerDeclaration& getDeclaration() const    { assert(mDeclaration != nullptr); return *mDeclaration; }
        
        VkSampler getVulkanSampler() const                  { return mVulkanSampler; }
 
    protected:
        void raiseChanged()                                 { if (mSamplerChangedCallback) mSamplerChangedCallback(*this); }
 
    private:
        RenderService*                  mRenderService = nullptr;
        VkDevice                        mDevice = VK_NULL_HANDLE;
        VkSampler                       mVulkanSampler = VK_NULL_HANDLE;
        const Sampler*                  mSampler = nullptr;
        const SamplerDeclaration*       mDeclaration = nullptr;
        SamplerChangedCallback          mSamplerChangedCallback;
    };
 
 
    // Sampler2DInstance
 
    class NAPAPI Sampler2DInstance : public SamplerInstance
    {
        RTTI_ENABLE(SamplerInstance)
    public:
        Sampler2DInstance(RenderService& renderService, const SamplerDeclaration& declaration, const Sampler2D* sampler2D, const SamplerChangedCallback& samplerChangedCallback);
 
        void setTexture(Texture2D& texture);
 
        bool hasTexture() const                 { return mTexture2D != nullptr; }
 
        const Texture2D& getTexture() const     { return *mTexture2D; }
 
    private:
        void onTextureChanged(const Texture2D&);
        rtti::ObjectPtr<Texture2D> mTexture2D = nullptr;
    };
 
 
    // Sampler2DArrayInstance
 
    class NAPAPI Sampler2DArrayInstance : public SamplerInstance
    {
        RTTI_ENABLE(SamplerInstance)
    public:
        Sampler2DArrayInstance(RenderService& renderService, const SamplerDeclaration& declaration, const Sampler2DArray* sampler2DArray, const SamplerChangedCallback& samplerChangedCallback);
 
        int getNumElements() const                              { return static_cast<int>(mTextures.size()); }
 
        bool hasTexture(int index) const                        { assert(index < mTextures.size()); return mTextures[index] != nullptr; }
 
        const Texture2D& getTexture(int index) const            { assert(index < mTextures.size()); return *mTextures[index]; }
 
        void setTexture(int index, Texture2D& texture);
 
        rtti::ObjectPtr<Texture2D>& operator[](size_t index)    { assert(index < mTextures.size()); return mTextures[index]; }
 
    private:
        std::vector<rtti::ObjectPtr<Texture2D>>                 mTextures;
    };
}