VulkanSession.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: 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 "NDEVRGraphics/Headers/GraphicsSession.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;
        void removeMaterial(const UUID& material) final override;
        void removeGeometry(const UUID& mesh) final 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 ensureExists(const Geometry & mesh);
        void ensureCameraExists(const UUID & camera);
        DynamicPointer<GraphicsPipeline> createRenderPipeline() final override;
        void destroySceneManager(const UUID& scene);
        void destroyVertexManager(const UUID& mesh);
        void destroyMaterialManager(const UUID& mat);
        void destroyCameraManager(const UUID& camera);
        void cleanupOldPipelines(GraphicsUpdateArguments& args);
 
        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 Geometry& 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 setupScene(GraphicsUpdateArguments& args) override;
        void addRenderObject(const Scene& scene, const Model& model, const Material& mat, const Geometry& mesh, PrimitiveProperty property) override;
        
 
        bool checkAddRenderObject(GraphicsUpdateArguments& args, Model& model);
        bool checkAddRenderObject(const Scene& scene, const Model& model, const Material& mat, const Geometry& mesh, PrimitiveProperty property);
        bool checkScene(GraphicsUpdateArguments& args);
 
        void pipelineSort(GraphicsUpdateArguments& args);
        void createModelPipeline(GraphicsUpdateArguments& args);
        bool createDescriptorPool(GraphicsUpdateArguments& args);
        //bool createModelDescriptorPool(GraphicsUpdateArguments& args);
        void cleanup() final override;
    protected:
        Dictionary<UUID, DynamicPointer<VulkanVertexManager>>   m_scene_managers;
        Dictionary<UUID, DynamicPointer<VulkanVertexManager>>   m_vertex_managers;
        Dictionary<UUID, DynamicPointer<VulkanMaterialManager>> m_material_managers;
        Dictionary<UUID, DynamicPointer<VulkanCameraManager>>   m_camera_managers;
 
        Dictionary<UUID, Dictionary<UUID, Dictionary<PrimitiveMode, VulkanRenderObject*>>> m_render_objects[2];
        Buffer<VulkanRenderObject*> m_pipelines;
 
        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_update_model_pool;
        //bool m_is_grab_pipeline;
        //uint04 m_model_descriptor_pool_size;
    };
}