texture.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 "surfacedescriptor.h"
#include "renderutils.h"
 
// External Includes
#include <nap/resource.h>
#include <glm/glm.hpp>
#include <nap/numeric.h>
#include <rtti/factory.h>
#include <nap/signalslot.h>
 
namespace nap
{
    // Forward Declares
    class Bitmap;
    class RenderService;
    class Core;
 
    class NAPAPI Texture : public Resource
    {
        friend class RenderService;
        RTTI_ENABLE(Resource)
    public:
        enum class EUsage
        {
            Static,             
            DynamicRead,        
            DynamicWrite        
        };
 
        // Constructor
        Texture(Core& core);
 
        // Destructor
        virtual ~Texture() { };
 
        virtual uint getLayerCount() const = 0;
 
        virtual uint getMipLevels() const = 0;
 
        virtual const ImageData& getHandle() const = 0;
 
        virtual VkImageLayout getTargetLayout() const           { return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; };
 
        VkFormat getFormat() const                              { return mFormat; }
 
        const SurfaceDescriptor& getDescriptor() const          { return mDescriptor; }
 
        RenderService& getRenderService()                       { return mRenderService; }
 
        const RenderService& getRenderService() const           { return mRenderService; }
 
        virtual void onDestroy() override                       { textureDestroyed(); }
 
        nap::Signal<> textureDestroyed;                         
 
    protected:
        virtual ImageData& getHandle() = 0;
 
        // Hide default resource init. Use specialized initialization functions instead.
        using Resource::init;
 
        virtual void clear(VkCommandBuffer commandBuffer);
 
        void requestClear();
 
        RenderService&                      mRenderService;                             
        SurfaceDescriptor                   mDescriptor;                                
        VkFormat                            mFormat = VK_FORMAT_UNDEFINED;              
        VkClearColorValue                   mClearColor = { 0.0f, 0.0f, 0.0f, 0.0f };   
    };
 
 
    class NAPAPI Texture2D : public Texture
    {
        friend class RenderService;
        RTTI_ENABLE(Texture)
    public:
        Texture2D(Core& core);
        virtual ~Texture2D() override;
 
        bool init(const SurfaceDescriptor& descriptor, bool generateMipMaps, const glm::vec4& clearColor, VkImageUsageFlags requiredFlags, utility::ErrorState& errorState);
 
        bool init(const SurfaceDescriptor& descriptor, bool generateMipMaps, VkImageUsageFlags requiredFlags, utility::ErrorState& errorState);
 
        bool init(const SurfaceDescriptor& descriptor, bool generateMipMaps, void* initialData, VkImageUsageFlags requiredFlags, utility::ErrorState& errorState);
 
        const glm::vec2 getSize() const                         { return { getWidth(), getHeight() }; }
 
        int getWidth() const                                    { return mDescriptor.mWidth; }
 
        int getHeight() const                                   { return mDescriptor.mHeight; }
 
        void update(const void* data, int width, int height, int pitch, ESurfaceChannels channels);
 
        void update(const void* data, const SurfaceDescriptor& surfaceDescriptor);
 
        virtual uint getLayerCount() const override             { return 1; }
 
        virtual uint getMipLevels() const override              { return mMipLevels; }
 
        virtual const ImageData& getHandle() const override     { return mImageData; }
 
        void asyncGetData(Bitmap& bitmap);
 
        void asyncGetData(std::function<void(const void*, size_t)> copyFunction);
 
        EUsage mUsage = EUsage::Static;                         
 
    protected:
        virtual ImageData& getHandle() override                 { return mImageData; }
 
        bool initInternal(const SurfaceDescriptor& descriptor, bool generateMipMaps, VkImageUsageFlags requiredFlags, utility::ErrorState& errorState);
 
        void upload(VkCommandBuffer commandBuffer);
 
        void download(VkCommandBuffer commandBuffer);
 
        void notifyDownloadReady(int frameIndex);
 
        void clearDownloads();
 
        using TextureReadCallback = std::function<void(void* data, size_t sizeInBytes)>;
 
        ImageData                           mImageData;                                 
        std::vector<BufferData>             mStagingBuffers;                            
        int                                 mCurrentStagingBufferIndex = -1;            
        size_t                              mImageSizeInBytes = -1;                     
        std::vector<TextureReadCallback>    mReadCallbacks;                             
        std::vector<int>                    mDownloadStagingBufferIndices;              
        uint32                              mMipLevels = 1;                             
    };
 
 
    class NAPAPI TextureCube : public Texture
    {
        friend class RenderService;
        RTTI_ENABLE(Texture)
    public:
        // The image layer count is equal to the number of sides of a cube
        static constexpr const uint layerCount = 6;
 
        TextureCube(Core& core);
        virtual ~TextureCube() override;
 
        bool init(const SurfaceDescriptor& descriptor, bool generateMipMaps, const glm::vec4& clearColor, VkImageUsageFlags requiredFlags, utility::ErrorState& errorState);
 
        const glm::vec2 getSize() const                         { return { getWidth(), getHeight() }; }
 
        int getWidth() const                                    { return mDescriptor.mWidth; }
 
        int getHeight() const                                   { return mDescriptor.mHeight; }
 
        VkImageUsageFlags getImageUsageFlags() const            { return mImageUsageFlags; }
 
        virtual uint getLayerCount() const override             { return layerCount; }
 
        virtual uint getMipLevels() const override              { return mMipLevels; }
 
        virtual const ImageData& getHandle() const override     { return mImageData; }
 
        virtual ImageData& getHandle() override                 { return mImageData; }
 
        const EUsage                        mUsage = EUsage::Static;                    
 
    protected:
        ImageData                           mImageData = { TextureCube::layerCount };   
        uint32                              mMipLevels = 1;                             
 
    private:
        VkImageUsageFlags                   mImageUsageFlags = 0;
    };
}