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&, int)>;
 
    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(int index = 0)                    { if (mSamplerChangedCallback) mSamplerChangedCallback(*this, index); }
 
        RenderService*                  mRenderService = nullptr;
        VkSampler                       mVulkanSampler = VK_NULL_HANDLE;
        const Sampler*                  mSampler = nullptr;
        const SamplerDeclaration*       mDeclaration = nullptr;
        SamplerChangedCallback          mSamplerChangedCallback;
    };
 
 
    // SamplerArrayInstance
 
    class NAPAPI SamplerArrayInstance : public SamplerInstance
    {
        RTTI_ENABLE(SamplerInstance)
    public:
        SamplerArrayInstance(RenderService& renderService, const SamplerDeclaration& declaration, const Sampler* sampler, const SamplerChangedCallback& samplerChangedCallback);
        virtual ~SamplerArrayInstance();
 
        virtual int getNumElements() const                  { return mDeclaration->mNumElements; }
    };
 
 
    // 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 onTextureDestroyed();
        nap::Slot<> textureDestroyedSlot = { [&]() -> void { onTextureDestroyed();  } };
 
        rtti::ObjectPtr<Texture2D> mTexture2D;
    };
 
 
    // Sampler2DArrayInstance
 
    class NAPAPI Sampler2DArrayInstance : public SamplerArrayInstance
    {
        RTTI_ENABLE(SamplerArrayInstance)
    public:
        Sampler2DArrayInstance(RenderService& renderService, const SamplerDeclaration& declaration, const Sampler2DArray* sampler2DArray, const SamplerChangedCallback& samplerChangedCallback);
 
        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;
    };
 
 
    // SamplerCubeInstance
 
    class NAPAPI SamplerCubeInstance : public SamplerInstance
    {
        RTTI_ENABLE(SamplerInstance)
    public:
        SamplerCubeInstance(RenderService& renderService, const SamplerDeclaration& declaration, const SamplerCube* samplerCube, const SamplerChangedCallback& samplerChangedCallback);
 
        void setTexture(TextureCube& textureCube);
 
        bool hasTexture() const                                 { return mTextureCube != nullptr; }
 
        const TextureCube& getTexture() const                   { assert(mTextureCube != nullptr); return *mTextureCube; }
 
    private:
        void onTextureDestroyed();
        nap::Slot<> textureDestroyedSlot = { [&]() -> void { onTextureDestroyed();  } };
 
        rtti::ObjectPtr<TextureCube> mTextureCube;
    };
 
 
    // SamplerCubeArrayInstance
 
    class NAPAPI SamplerCubeArrayInstance : public SamplerArrayInstance
    {
        RTTI_ENABLE(SamplerArrayInstance)
    public:
        SamplerCubeArrayInstance(RenderService& renderService, const SamplerDeclaration& declaration, const SamplerCubeArray* samplerCubeArray, const SamplerChangedCallback& samplerChangedCallback);
 
        bool hasTexture(int index) const                        { assert(index < mTextures.size()); return mTextures[index] != nullptr; }
 
        const TextureCube& getTexture(int index) const          { assert(index < mTextures.size()); return *mTextures[index]; }
 
        void setTexture(int index, TextureCube& textureCube);
 
        rtti::ObjectPtr<TextureCube>& operator[](size_t index)  { assert(index < mTextures.size()); return mTextures[index]; }
 
    private:
        std::vector<rtti::ObjectPtr<TextureCube>> mTextures;
    };
}