VulkanRenderObject.h

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
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 = Matrix<fltp04>(1);
            Vector<3, sint04> model_offset = Vector<3, sint04>(0);
            VulkanBitflagObject flags;
            RGBColor custom_color = Constant<RGBColor>::NaN;
            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, const Material& material)
                : model(model)
                , material(material)
            {}
            Model model;
            Material material;
            bool is_visible = false;
        };
        struct GeoProperties
        {
            GeoProperties(const Geometry& geo)
                : geometry(geo)
            {}
            Buffer<ModelProperties> model_parents;
            Geometry geometry;
            fltp04 pixel_thickness = Constant<fltp04>::NaN;
            uint04 vertex_start = 0;
            uint04 vertex_size  = 0;
            uint04 index_start  = 0;
            uint04 index_size   = 0;
            bool is_visible = false;
        };
        
    public:
        VulkanRenderObject(const ConstPointer<VulkanDevice>& pipeline);
        VulkanRenderObject(const VulkanRenderObject& instance);
        ~VulkanRenderObject();
        void cleanup();
 
        VkPipeline getPipeline() { return m_graphics_pipeline; }
        void setDevice(const DynamicPointer<VulkanDevice>& instance);
        void updateUniformBuffer(GraphicsUpdateArguments& args);
        void commit(GraphicsUpdateArguments& args);
        bool hasOpacity() const;
        bool hasImage() const;
        fltp04 fadeDistance() const;
        uint01 parity() const { return m_parity; }
        
        bool createPipeline(GraphicsUpdateArguments& args);
 
        Buffer<VkPipelineShaderStageCreateInfo, uint04, ObjectAllocator<true>> getShaderCreateInfo() const;
        
        //void resetPool() { m_descriptor_pool = nullptr; }
        bool hasCommand() const;
        bool runCommand(GraphicsUpdateArguments& args, VkDescriptorSet camera_descriptor);
        bool isFilledShape() const;
        
        void setGraphicsPipeline(VkPipeline m_pipeline);
        Buffer<VkVertexInputAttributeDescription, uint04, ObjectAllocator<true>> attributeDescriptions(GraphicsUpdateArguments& args) const;
        Buffer<VkVertexInputBindingDescription, uint04, ObjectAllocator<true>> bindingDescriptions(GraphicsUpdateArguments& args) const;
        void setPrimitiveMode(const PrimitiveMode& type) { m_index_mode = type; }
        void setIndexProperty(const PrimitiveProperty& property) { m_index_property = property; }
        void setVertexManager(const DynamicPointer<VulkanVertexManager>& vertex_manager);
        void setMaterialManager(const DynamicPointer<VulkanMaterialManager>& material_manager);
        void setParity(uint01 parity);
        const ConstPointer<VulkanMaterialManager>& materialManager() const { return m_material_manager;}
        const ConstPointer<VulkanVertexManager>& vertexManager() const { return m_vertex_manager; }
        PrimitiveMode indexMode() const { return m_index_mode; };
        PrimitiveProperty indexProperty() const { return m_index_property; };
        void addInstance(const Geometry& geo, const Model& parent, const Material& material);
        void clearInstances();
 
        
 
        //static VkDescriptorSetLayout_T* descriptorSetLayout(ConstPointer<VulkanDevice> instance);
        static VkPipelineLayout pipelineLayout(ConstPointer<VulkanDevice> instance);
    private:
        void drawInstances(uint04 start, uint04 size, uint04 mesh_index, const GraphicsUpdateArguments& args, bool& is_index_bound);
        void processGeoUniformUpdates(GeoProperties& properties, GraphicsUpdateArguments& args, uint04& matrix_index, Buffer<Model>& models_to_re_add, const Time& geo_mod_time);
        
        
        //ExtraPropertySettings getExtraProperty(const GraphicsUpdateArguments& args) const;
        VulkanBitflagObject getBitflagObject(const Geometry& mesh, const Model& model, const GraphicsUpdateArguments& args) const;
        //void createDescriptorSet(VkDescriptorPool_T* pool, bool is_new_pool);
        
        Buffer<bool> getExclusionList(const GraphicsUpdateArguments& args) const;
        Buffer<ModelMatrixUniformObject> getMatrixUniformObject(const GraphicsUpdateArguments& args) const;
        ModelMatrixUniformObject getMatrixUniformObject(const GraphicsUpdateArguments& args, const Geometry& mesh, const Model& model) const;
    private:
        Buffer<VkVertexInputAttributeDescription, uint04, ObjectAllocator<true>> calculateAttributeDescriptions(GraphicsUpdateArguments& args) const;
        Buffer<VkVertexInputBindingDescription, uint04, ObjectAllocator<true>> calculateBindingDescriptions(GraphicsUpdateArguments& args) const;
        PrimitiveProperty m_index_property;
        PrimitiveMode m_index_mode;
        Buffer<GeoProperties> m_geometries;
        Dictionary<UUID, uint04> m_geometry_lookup;
        //ExtraPropertySettings m_extra_settings;
 
        //DynamicPointer<VulkanBuffer> m_bitf_uniform_buffer;
        DynamicPointer<VulkanVertexManager> m_vertex_manager;
        ConstPointer<VulkanMaterialManager> m_material_manager;
        mutable Buffer<VkVertexInputAttributeDescription, uint04, ObjectAllocator<true>> m_attribute_descriptions;
        mutable Buffer<VkVertexInputBindingDescription, uint04, ObjectAllocator<true>> m_binding_descriptions;
 
        Buffer<ModelMatrixUniformObject> m_model_matrix_uniforms;
        DynamicPointer<VulkanBuffer> m_matrix_instance_buffer;
 
        ConstPointer<VulkanDevice> m_instance;
        
        VkPipeline       m_graphics_pipeline;
        //VkDescriptorPool_T* m_descriptor_pool;
        //VkDescriptorSet_T*  m_descriptor_set;
 
        Time m_last_updated_time;
        volatile mutable bool m_needs_matrix_commit;
        //volatile mutable bool m_needs_bitf_commit;
        uint01 m_parity;
    };
}
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);