VulkanSession.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: VulkanSession
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "VulkanDefines.h"
#include "VulkanDevice.h"
#include "VulkanCameraManager.h"
#include "VulkanVertexManager.h"
#include "VulkanMaterialManager.h"
#include <NDEVR/GraphicsSession.h>
#include <NDEVR/ModelGeoMaterial.h>
DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache);
namespace NDEVR
{
    class VulkanRenderObject;
    class VulkanRenderDefinition;
    class VulkanSession : public GraphicsSession
    {
    public:
        VulkanSession(const DynamicPointer<VulkanDevice>& instance);
        ~VulkanSession();
        //virtual void setDevice(const DynamicPointer<GraphicsDevice>& instance) override;
        virtual const ConstPointer<GraphicsDevice>& device() const final override { return m_graphics_device; };
        virtual const DynamicPointer<GraphicsDevice>& device() final override { return m_graphics_device; };
        void ensureCameraExists(const UUID & camera);
        void setupRasterizers();
        void setupAssemblyInputs();
        DynamicPointer<GraphicsPipeline> createRenderPipeline() final override;
        void destroySceneManager(const UUID& scene);
        void destroyMaterialManager(const UUID& mat);
        void destroyCameraManager(const UUID& camera);
        void cleanupOldPipelines(GraphicsUpdateArguments& args);
        static UUID VulkanRenderEngineID() { return UUID::CreateUUID("Vulkan Render Engine"); }
        void updateUniformBuffer(GraphicsUpdateArguments& args) final override;
        bool createPipeline(GraphicsUpdateArguments& args) final override;
        void commit(GraphicsUpdateArguments& args) final override;
        bool hasCommand() const override;
        UUID uuid() const { return m_uuid; }
        virtual void postClearAll() final override;
        bool runCommand(GraphicsUpdateArguments& args) final override;
        DynamicPointer<VulkanCameraManager>   getCameraManager(const UUID& camera);
        DynamicPointer<VulkanMaterialManager> getMaterialManager(const Material& mat);
        DynamicPointer<VulkanMaterialManager> getMaterialManager(const UUID& id);
        DynamicPointer<VulkanVertexManager>   getVertexManager(const Scene& mesh);
        void setRenderDefinition(const DynamicPointer<VulkanRenderDefinition>& def);
        DynamicPointer<VulkanShaderManager> shaderManager() { return m_shader_manager; }
        virtual UUID uuid() final override { return m_device->id(); };
        //virtual void setDevice(const DynamicPointer<GraphicsDevice>& instance) = 0;
        virtual void drawFrame(GraphicsUpdateArguments&) final override {};
        virtual void ensureLastRenderComplete() final override {};
        virtual void setWindowInstance(WindowInstance*) final override {};
        virtual void cleanResources() final override {};
        virtual void init(GraphicsUpdateArguments&) final override {};
    protected:
        virtual void clearAll();
        void clearScene();
        void updateCameraPipeline(GraphicsUpdateArguments& args);
        bool addRenderGeometry(const Geometry& geo) override;
        void removeRenderGeometry(const Geometry& geo) override;
        bool checkPipeline(bool add_if_needed);
        bool checkPipeline(GeometryUpdateObject& geo, bool add_if_needed);
        void pipelineSort(GraphicsUpdateArguments& args);
        void createModelPipeline(GraphicsUpdateArguments& args);
        bool createDescriptorPool(GraphicsUpdateArguments& args);
        //bool createModelDescriptorPool(GraphicsUpdateArguments& args);
        void cleanup() final override;
    private:
        void createPipelineInput();
    protected:
        Dictionary<UUID, DynamicPointer<VulkanVertexManager>>   m_scene_managers;
        Dictionary<UUID, DynamicPointer<VulkanMaterialManager>> m_material_managers;
        Dictionary<UUID, DynamicPointer<VulkanCameraManager>>   m_camera_managers;
        Dictionary<size_t, VulkanRenderObject*> m_render_objects;
        Buffer<VulkanRenderObject*> m_pipelines;
        Buffer<VkGraphicsPipelineCreateInfo> m_pipeline_info_buffer;
        enum RasterizerType
        {
              e_filled_cull_cw      
            , e_filled_cull_ccw     
            , e_filled_cull_none    
            , e_outline             
            , e_size                
        };
        Buffer<GeometryUpdateObject> m_geometries;
        Vector<RasterizerType::e_size, VkPipelineRasterizationStateCreateInfo> m_rasterizer;
        Vector<cast<uint01>(VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN + 1), VkPipelineInputAssemblyStateCreateInfo> m_assembly_input;
        Buffer<VkPipelineVertexInputStateCreateInfo> m_vertex_input_info;
        DynamicPointer<VulkanImageManager> m_image_manager;
        DynamicPointer<VulkanShaderManager> m_shader_manager;
        DynamicPointer<VulkanRenderDefinition> m_render_definition;
        DynamicPointer<GraphicsDevice> m_graphics_device;
        DynamicPointer<VulkanDevice> m_device;
        VkDescriptorPool m_descriptor_pool;
        //VkDescriptorPool_T* m_model_descriptor_pool;
        VkPipelineCache m_model_pipeline_cache;
        uint04 m_num_of_images;
        uint04 m_num_of_materials;
        uint04 m_num_of_cameras;
 
        UUID m_uuid;
        bool m_needs_pipeline_update = false;
        //bool m_is_grab_pipeline;
        //uint04 m_model_descriptor_pool_size;
    };
}