VulkanRenderObject.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: VulkanRenderObject
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "VulkanDefines.h"
#include "VulkanImage.h"
#include "VulkanBuffer.h"
#include "VulkanBitflagObject.h"
#include "NDEVRGraphics/Headers/GraphicsUpdateArguments.h"
#include "Design/Headers/Material.h"
#include "Design/Headers/Geometry.h"
#include "Design/Headers/Model.h"
#include "Base/Headers/Pointer.hpp"
#include "Base/Headers/RGBColor.h"
#include "Base/Headers/Bounds.hpp"
 
 
struct VkCommandBuffer_T;
struct VkDescriptorSetLayout_T;
struct VkDescriptorPool_T;
struct VkDescriptorSet_T;
struct VkSampler_T;
struct VkVertexInputAttributeDescription;
struct VkVertexInputBindingDescription;
struct VkPipelineShaderStageCreateInfo;
 
DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline);
DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout);
 
namespace NDEVR
{
    class Camera;
    class VulkanVertexManager;
    class VulkanMaterialManager;
    
    class VulkanRenderObject
    {
        struct ModelMatrixUniformObject
        {
            Matrix<fltp04> model_transform = Constant<Matrix<fltp04>>::Invalid; 
            Vector<3, sint04> model_offset = Vector<3, sint04>(0);              
            VulkanBitflagObject flags;                                          
            RGBColor custom_color = Constant<RGBColor>::Invalid;                
            bool operator==(const ModelMatrixUniformObject& object) const
            {
                return model_transform == object.model_transform
                    && flags == object.flags
                    && model_offset == object.model_offset
                    && custom_color == object.custom_color;
            }
            bool operator!=(const ModelMatrixUniformObject& object) const
            {
                return model_transform != object.model_transform
                    || flags != object.flags
                    || model_offset != object.model_offset
                    || custom_color != object.custom_color;
            }
        };
    protected:
        struct ModelProperties
        {
            ModelProperties(const Model& model)
                : model_id(model.get<NDPO::guid>())
            {
                is_visible = model.isVisible();
            }
            Time updated_time = Constant<Time>::Invalid;    
            UUID model_id = Constant<UUID>::Invalid;        
            uint01 parity = 0U;                             
            bool is_visible = false;                        
        };

        struct GeoProperties
        {
            GeoProperties(const Geometry& geo);
            Buffer<ModelProperties> model_parents;              
            Geometry geometry;                                  
            Time modified_time = Time(0);                       
            fltp04 pixel_thickness = Constant<fltp04>::Invalid; 
            uint04 vertex_start = 0;                            
            uint04 vertex_size = 0;                             
            uint04 index_start = 0;                             
            uint04 index_size = 0;                              
            bool is_visible = false;                            
            bool is_deleted = false;                            
        };
    public:
        VulkanRenderObject(const ConstPointer<VulkanDevice>& pipeline);
        VulkanRenderObject(const VulkanRenderObject&) = delete;
        ~VulkanRenderObject();
        void cleanup();
        VkPipeline getPipeline() { return m_graphics_pipeline; }
        void setDevice(const DynamicPointer<VulkanDevice>& instance);
        void updateUniformBuffer(GraphicsUpdateArguments& args);
        bool hasOpacity() const;
        bool hasImage() const;
        bool hasParity() const;
        fltp04 fadeDistance() const;
        bool hasTangent() const { return m_has_tangent; }
        bool createPipeline(GraphicsUpdateArguments& args);
        //void resetPool() { m_descriptor_pool = nullptr; }
        bool runCommand(GraphicsUpdateArguments& args, VkDescriptorSet camera_descriptor);
        bool runCommandPass(GraphicsUpdateArguments& args, uint01 parity) const;
        bool isFilledShape() const;
        void setGraphicsPipeline(VkPipeline pipeline);
        bool hasActiveGeo() const;
        void setParityGraphicsPipeline(VkPipeline pipeline);
        Vector<2, VkPipelineShaderStageCreateInfo> getShaderCreateInfo() const;
        const PrimitiveBuffer<VkVertexInputAttributeDescription>& getAttributeDescriptions() const;
        const PrimitiveBuffer<VkVertexInputBindingDescription>& getBindingDescriptions() const;
        const ConstPointer<VulkanMaterialManager>& materialManager() const { return m_material_manager; }
        const ConstPointer<VulkanVertexManager>& vertexManager() const { return m_vertex_manager; }
        PrimitiveMode primitiveMode() const { return m_index_mode; };
        PrimitiveProperty primitiveProperty() const { return m_index_property; };
        void setPrimitiveMode(const PrimitiveMode& type) { m_index_mode = type; }
        void setPrimitiveProperty(const PrimitiveProperty& property) { m_index_property = property; }
        void setVertexManager(const DynamicPointer<VulkanVertexManager>& vertex_manager);
        void setMaterialManager(const DynamicPointer<VulkanMaterialManager>& material_manager);
        void setHasTangent(bool has_tangent);
        void addInstance(const Geometry& geo);
        bool removeInstance(const Geometry& geo);
        void setMaterial(const Material& material);
        void clearInstances();
        void updateVertexBuffers(GraphicsUpdateArguments& args, bool can_reallocate = true);
        bool needsPipelineUpdate() const { return m_needs_pipeline_update; }
        void finishUpdatingPipeline() { m_needs_pipeline_update = false; }
    public:
        static VkPipelineLayout PipelineLayout(ConstPointer<VulkanDevice> instance);
    private:
        bool computeHasActiveGeo();
        void drawInstances(uint04 start, uint04 size, const GeoProperties& geo, const GraphicsUpdateArguments& args, bool& is_index_bound) const;
        VulkanBitflagObject getBitflagObject(const Geometry& mesh, const Model& model) const;
        //returns false if nothing to render
        bool getExclusionList(GraphicsUpdateArguments& args, uint01 parity) const;
        void updateBufferCache(GraphicsUpdateArguments& args);
        void updateModelParents(uint04 geo_index, uint04& matrix_idx);
        ModelMatrixUniformObject getMatrixUniformObject(const Geometry& geo, const Model& model) const;
        PrimitiveBuffer<VkVertexInputAttributeDescription>& calculateAttributeDescriptions(PrimitiveBuffer<VkVertexInputAttributeDescription>& buffer, GraphicsUpdateArguments& args) const;
        PrimitiveBuffer<VkVertexInputBindingDescription>& calculateBindingDescriptions(PrimitiveBuffer<VkVertexInputBindingDescription>& buffer, GraphicsUpdateArguments& args) const;
    private:
        Time m_last_buffer_time = Time(0);
        UUID m_material_id;
        PrimitiveProperty m_index_property;
        PrimitiveMode m_index_mode;
        Set<Geometry> m_added_geos;
        Buffer<GeoProperties> m_geometries;
        //ExtraPropertySettings m_extra_settings;
        String m_extra_property;
        //DynamicPointer<VulkanBuffer> m_bitf_uniform_buffer;
        DynamicPointer<VulkanVertexManager> m_vertex_manager;
        ConstPointer<VulkanMaterialManager> m_material_manager;
        PrimitiveBuffer<VkVertexInputAttributeDescription> m_attribute_descriptions;
        mutable PrimitiveBuffer<VkVertexInputAttributeDescription> m_attribute_descriptions_buffer;
        PrimitiveBuffer<VkVertexInputBindingDescription> m_binding_descriptions;
        mutable PrimitiveBuffer<VkVertexInputBindingDescription> m_binding_descriptions_buffer;
        VkBuffer m_vertex_buffers[9];
        Buffer<ModelMatrixUniformObject> m_model_matrix_uniforms;
        DynamicPointer<VulkanBuffer> m_matrix_instance_buffer;
        ConstPointer<VulkanDevice> m_instance;
        VkPipeline m_graphics_pipeline;
        VkPipeline m_parity_pipeline;
        uint04 m_matrix_index_offset = 0;
        uint04 m_wait_count = 0;
        uint08 m_buffer_update_idx = Constant<uint08>::Invalid;
        bool m_has_tangent = false;
        bool m_has_parity = false;
        volatile mutable bool m_needs_matrix_commit;
        volatile mutable bool m_needs_pipeline_update = true;
        bool m_has_instance_difference = false;
        bool m_needs_command_refresh = false;
        bool m_has_active_geo = false;
    };
}
bool operator!=(const VkVertexInputAttributeDescription& a, const VkVertexInputAttributeDescription& b);
bool operator!=(const VkVertexInputBindingDescription& a, const VkVertexInputBindingDescription& b);
bool operator==(const VkVertexInputAttributeDescription& a, const VkVertexInputAttributeDescription& b);
bool operator==(const VkVertexInputBindingDescription& a, const VkVertexInputBindingDescription& b);