VulkanMaterialManager.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: VulkanMaterialManager
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "VulkanDefines.h"
#include "VulkanBuffer.h"
#include "VulkanImage.h"
#include "VulkanShader.h"
#include "VulkanBitflagObject.h"
#include <NDEVR/Model.h>
#include <NDEVR/Material.h>
struct VkWriteDescriptorSet;
struct VkDescriptorImageInfo;
struct VkPipelineShaderStageCreateInfo;
DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool);
DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet);
DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout);
DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler);
namespace NDEVR
{
    class GraphicsUpdateArguments;
    struct VulkanVertexUniformObject
    {
        fltp04 pixel_thickness = 1.0;   
        fltp04 reserved0 = 0.0;         
        fltp04 reserved1 = 0.0;         
        fltp04 reserved2 = 0.0;         
    };
    static_assert(sizeof(VulkanVertexUniformObject) == 16, "Bad VertexUniformSize");
#pragma pack(push, 1)
    struct FragUniformObject
    {
        enum ColorPosition : uint01
        {
              e_kd_frag_pos = 8     
            , e_ka_frag_pos = 9     
            , e_ks_frag_pos = 10    
            , e_kr_frag_pos = 11    
        };

        enum FloatPosition : uint01
        {
              e_min_value_frag_pos = 0  
            , e_mid_value_frag_pos = 1  
            , e_max_value_frag_pos = 2  
        };
        Vector<16, fltp04> float_values;
        Vector<12, RGBColor> palette_colors;
        Vector<4, sint04> m_grid_lines = Vector<4, sint04>(-1);
        Vector<4, sint04> m_grid_lines_desc = Vector<4, sint04>(-1);
        fltp04 fade_distance = 99.9f;
        fltp04 max_distance = 500.0f;
 
        fltp04 shininess = 1.0f;
        fltp04 opacity = 1.0f;
        uint04 layer_number = Constant<uint04>::Invalid;
 
        uint04 texture_coord_mode = 0;
        uint04 palette_size = 0;
        VulkanBitflagObject tex_flags;
 
    public:
        FragUniformObject()
            : palette_colors(Constant<RGBColor>::Invalid)
        {
        }
        FragUniformObject(const Material& m_material);
        void setMode(Material::TextureCoordMode mat_mode)
        {
            texture_coord_mode = mat_mode;
        }
    };
    //static_assert(sizeof(FragUniformObject) == 176, "Bad UniformSize");
    static_assert(sizeof(FragUniformObject) == 176, "Bad FragUniformSize");
#pragma pack(pop)
    class VulkanMaterialManager
    {
    public:
        VulkanMaterialManager(const ConstPointer<VulkanDevice>& device);
        VulkanMaterialManager(const VulkanMaterialManager& m_pipeline) = delete;
        ~VulkanMaterialManager();
 
        void cleanup();
        VulkanBitflagObject getUVImageFlags(const Material& material) const;
        VulkanBitflagObject uvImageFlags() const { return m_last_image_flag_object; }
        bool hasGrid() const { return m_has_grid; }
        void checkImages();
        VulkanVertexUniformObject getVulkanVertexUniformObject(const Material& material, const GraphicsUpdateArguments& args) const;
        const VulkanVertexUniformObject& vertexUniform() const { return m_vert_uniform; }
        FragUniformObject getFragUniformObject(const Material& material) const;
        VulkanBitflagObject getBitflagObject() const;
        void updateUniformBuffer(GraphicsUpdateArguments& args);
        void addMaterial(const Material& material);
        void clearMaterials();
        bool hasOpacity() const { return m_has_opacity; }
        bool ignoreDepth() const { return m_ignore_depth; }
        bool writeToDepth() const { return m_write_to_depth; }
        bool usesModelColor() const { return m_use_model_color; }
        bool usesLayerColor() const { return m_use_layer_color; }
        bool needsPipelineUpdate() const { return m_needs_pipeline_update; }
        fltp04 fadeDistance() const;
        fltp04 depthBias() const { return m_depth_bias; }
        bool hasImage() const;
        void commit();
        void createPipeline(GraphicsUpdateArguments& args, DynamicPointer<VulkanShaderManager>& shader_manager, DynamicPointer<VulkanImageManager>& image_manager, VkDescriptorPool pool);
        void updateBuffers(GraphicsUpdateArguments& args, DynamicPointer<VulkanImageManager>& image_manager);
 
        uint04 getNumberOfImages(const GraphicsUpdateArguments& args) const;
 
        StringView getColorByChannel(GraphicsUpdateArguments& args) const;
 
        StringView getExtraPropertyChannel() const { return m_extra_channel; }
 
        //void setFragmentShader(const Pointer<Shader>& shader) { m_fragment_shader = shader; }
        ConstPointer<VulkanShader> getFragmentShader(VulkanShaderManager::ShaderType shader_type) const;
        VkPipelineShaderStageCreateInfo getShaderCreateInfo(VulkanShaderManager::ShaderType shader_type) const;
        void createSampler(const GraphicsUpdateArguments& args);
 
        VkDescriptorSet descriptorSet() const
        {
            return m_descriptor_set;
        }
        
        
        Time lastDependencyUpdate() const { return m_last_push_update_time; }
        UUID material() const;
        bool isTwoSided() const { return m_is_two_sided; }
        bool isWireframe() const { return m_is_wireframe; }
        bool overrideCamera() const { return m_override_camera; }
        bool useNormalForTexture() const { return m_use_normal_for_texture; }
        bool useLighting() const;
        bool smoothNormals() const;
 
        bool simpleAllowed() const;
        void resetPool() { m_descriptor_pool = vk_null; }
        static VkDescriptorSetLayout descriptorSetLayout(ConstPointer<VulkanDevice> device);
        UUID id() const;
        static UUID MaterialID(const Material& material);
    protected:
        
        void createDescriptorSet(VkDescriptorPool pool, const GraphicsUpdateArguments& args);
        void getDescriptorWrites(Buffer<VkWriteDescriptorSet>& descriptor_writes, Buffer<VkDescriptorImageInfo>& image_info) const;
        
        void updateShader(const Material& mat, const GraphicsUpdateArguments& args, DynamicPointer<VulkanShaderManager>& shader_manager);
        void updateImages(const Material& mat, const GraphicsUpdateArguments& args, DynamicPointer<VulkanImageManager>& image_manager);
        bool needsToUpdateImage(const Material& material);
        bool needsToUpdateShader(const Material& material);
        
        uint04 getLayerNumber(const Material& material) const;
 
 
    protected:
        
 
        Buffer<Material> m_materials;
        VkSampler m_sampler;
        VulkanBitflagObject m_last_image_flag_object;
        VkDescriptorPool m_descriptor_pool;
        ConstPointer<VulkanDevice> m_device;
 
        VulkanVertexUniformObject m_vert_uniform;
        FragUniformObject   m_frag_uniform;
 
        DynamicPointer<VulkanBuffer> m_vertex_uniform_buffer;
        DynamicPointer<VulkanBuffer> m_frag_uniform_buffer;
        
        //ConstPointer<Shader> m_fragment_shader;
 
        ConstPointer<VulkanImageData> m_uv_data[cast<uint04>(UVType::e_uv_size)];
        ConstPointer<VulkanImageView> m_uv_view[cast<uint04>(UVType::e_uv_size)];
        uint04 m_number_of_uniforms;
        Time m_last_updated_time;
 
        Time m_last_push_update_time;
 
        String m_image_address[cast<uint04>(UVType::e_uv_size)];
        
 
        VkDescriptorSet m_descriptor_set;
        String m_extra_channel;
        Vector<3, Material::TileTextureMode> m_texture_tile_mode;
 
        DynamicPointer<VulkanShaderManager> m_shader_manager;
        Material::ShadingModel m_shade_model;
        String m_shader_name;
        fltp04 m_depth_bias;
        
        mutable bool m_needs_to_commit_frag_buffer = true;
        mutable bool m_needs_to_commit_vert_buffer = true;
        bool m_needs_pipeline_update = true;
        bool m_has_opacity = false;
        bool m_has_image = false;
        bool m_has_image_opacity = false;
        bool m_is_two_sided = false;
        bool m_override_camera = false;
        bool m_smooth_normals = false;
        bool m_is_wireframe = false;
        bool m_has_grid = false;
        bool m_use_normal_for_texture = false;
        bool m_use_model_color = false;
        bool m_use_layer_color = false;
        bool m_ignore_depth = false;
        bool m_write_to_depth = true;
        bool m_needs_buffer_update = false;
        uint04 m_layer_number;
        UUID m_id;
    };
}