VulkanImage.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Graphics
File: VulkanImage
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "VulkanDefines.h"
#include "VulkanDevice.h"
#include <NDEVR/Image.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/File.h>
#include <NDEVR/RGBColor.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/Buffer.h>
 
typedef uint32_t VkImageUsageFlags;
typedef uint32_t VkMemoryPropertyFlags;
namespace NDEVR
{
    class File;
    class VulkanInstance;
    class VulkanBuffer;
    class VulkanImageData : public Image
    {
    public:
        VulkanImageData(const ConstPointer<VulkanDevice>& instance);
        VulkanImageData(VulkanImageData&& instance) noexcept;
        VulkanImageData(const ConstPointer<VulkanDevice>& instance, const StringView& image_id, uint04 mip_map_depth);
        VulkanImageData(const ConstPointer<VulkanDevice>& instance, Buffer<String>& image_ids, uint04 mip_map_depth);
        VulkanImageData(const ConstPointer<VulkanDevice>& instance, VkImage image, Vector<2, uint04> size, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, bool image_owner);
        VulkanImageData(const ConstPointer<VulkanDevice>& instance, Vector<2, uint04> size, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties);
        ~VulkanImageData();
        void clear(const RGBColor& color = RGBColor(0,0,0,0), VkCommandBuffer_T* command = nullptr);
        uint04 mipMapDepth() const { return m_mip_map_depth; };
        void setMipMapDepth(uint04 depth) { m_mip_map_depth = depth; };

        uint04 arrayLayers() const { return m_array_layers; }
        void setArrayLayers(uint04 array_layers) { m_array_layers = array_layers; }

        const Time& getModifiedTime() const { return m_modified_time; }
        Vector<2, uint04> getMipSize(uint04 level) const;
        VkFormat getFormat() const;
        void setFormat(VkFormat format);

        void setDevice(const ConstPointer<VulkanDevice>& instance);
        void cleanup(bool destroy_memory = true);
        Vector<2, uint04> size() const final override;
        ConstPointer<VulkanDevice> device() const { return m_device; }

        VkImage vulkanImage() const { return m_vulkan_image; };
        VkDeviceMemory vkMemory() const { return m_image_memory; }
        static VkSampleCountFlagBits getSampleBitflags(uint04 multi_sample_count);
        void setImageProperties(Vector<2, uint04> size, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties);

        void transitionImageLayout(VkImageLayout newLayout, VkCommandBuffer_T* command = nullptr);
        void transitionImageLayout(VkImageLayout newLayout, uint04 miplevel, uint04 level, VkCommandBuffer_T* command = nullptr);
        void setMultiSampleCount(uint04 count) { m_multi_sample_count = count; };
        void setData(const StringView& image_id, uint04 layer);
        void setData(VkImage image, bool image_owner);
        bool hasAlpha() const { return m_has_alpha; }
        void rawSetLayout(VkImageLayout layout);
        VkImageLayout layout(uint04 mip_level = 0) const;
        void checkAndUpdateMemory(VkMemoryPropertyFlags properties, bool bind_image);
    public:
        void createImage(VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties);
    private:
        uint04 computeOffset(uint04 mip_level, uint04 image_layer);
        VkImage m_vulkan_image;                 
        Time m_modified_time;                   
        Vector<2, uint04> m_size;               
        uint04 m_allocated_size;                
        VkDeviceMemory m_image_memory;          
        ConstPointer<VulkanDevice> m_device;    
        uint08 m_layout[32];                    
        uint08 m_format;                        
        uint04 m_mip_map_depth;                 
        uint04 m_array_layers;                  
        uint04 m_multi_sample_count;            
        uint04 m_bytes_per_pixel = 4;           
        bool m_has_alpha;                       
        bool m_image_owner;                     
    };

    class VulkanImageManager
    {
    public:
        VulkanImageManager(const ConstPointer<VulkanDevice>& instance);
        ~VulkanImageManager();
        bool updateImages();
        bool needsImageUpdate(Time time);
        ConstPointer<VulkanImageData> getImage(const StringView& file);
 
        Dictionary<String, DynamicPointer<VulkanImageData>> m_file_map; 
        ConstPointer<VulkanDevice> m_device;        
        uint04 m_mip_map_depth;                     
        Time m_check_time;                          
    };

    class VulkanImageView
    {
    public:
        VulkanImageView(const ConstPointer<VulkanImageData>& data, uint04 aspectFlags, bool create = true);
        VulkanImageView(VulkanImageView&& old);
        ~VulkanImageView();
        bool needsUpdate() const;
        void create();
        VkImageView vkImageView() const { return m_view; }
        void cleanup();
    private:
        VkImageView m_view;                         
        VkImage m_last_image;                       
        ConstPointer<VulkanImageData> m_data;       
        uint04 m_aspect_flags;                      
    };
}