-Dev: headless rendering support + test. Caputuring of attachments and save to CPU done

Author: AEspinosaDev

include/engine/core/passes/tonemapping_pass.h

@@ -25,7 +25,7 @@ enum TonemappingType
 /*
 Tonemapping Pass.
 */
-class TonemappingPass final : public PostProcessPass<1, 0>
+class TonemappingPass final : public PostProcessPass<1, 1>
 {
   protected:
     float           m_exposure = 1.0f;
@@ -45,7 +45,7 @@ class TonemappingPass final : public PostProcessPass<1, 0>
                - Tonemapped Color
 
            */
-    TonemappingPass(Graphics::Device* device, const PassLinkage<1, 0>& config, Extent2D extent, ColorFormatType colorFormat, bool isDefault = true)
+    TonemappingPass(Graphics::Device* device, const PassLinkage<1, 1>& config, Extent2D extent, ColorFormatType colorFormat, bool isDefault = true)
         : PostProcessPass(device, config, extent, colorFormat, ENGINE_RESOURCES_PATH "shaders/misc/tonemapping.glsl", "TONEMAPPING", isDefault) {
         m_interAttachments.resize(1);
     }

include/engine/core/resource_manager.h

@@ -54,16 +54,13 @@ class ResourceManager
     static void update_global_data(Graphics::Device* const device,
                                    Graphics::Frame* const  currentFrame,
                                    Core::Scene* const      scene,
-                                   Core::IWindow* const    window,
+                                   Extent2D                displayExtent,
                                    bool                    jitterCamera);
     /*
     Object descriptor layouts uniforms buffer upload to GPU
     */
-    static void update_object_data(Graphics::Device* const device,
-                                   Graphics::Frame* const  currentFrame,
-                                   Core::Scene* const      scene,
-                                   Core::IWindow* const    window,
-                                   bool                    enableRT);
+    static void
+    update_object_data(Graphics::Device* const device, Graphics::Frame* const currentFrame, Core::Scene* const scene, Extent2D displayExtent, bool enableRT);
     /*
     Initialize and setup texture IMAGE
     */
@@ -72,8 +69,7 @@ class ResourceManager
     /*
     Upload geometry vertex buffers to the GPU
     */
-    static void
-    upload_geometry_data(Graphics::Device* const device, Core::Geometry* const g, bool createAccelStructure = true);
+    static void upload_geometry_data(Graphics::Device* const device, Core::Geometry* const g, bool createAccelStructure = true);
     static void destroy_geometry_data(Core::Geometry* const g);
     /*
     Uploads scene's skybox resources (cube mesh and panorama texture)

include/engine/core/textures/textureLDR.h

@@ -36,6 +36,9 @@ class TextureLDR : public ITexture
         , m_tmpCache(data) {
         m_image.loadedOnCPU = true;
     }
+    ~TextureLDR(){
+        free(m_tmpCache);
+    }
 
     inline void set_image_cache(void* cache, Extent3D extent, uint16_t channels) {
         m_tmpCache          = static_cast<unsigned char*>(cache);

include/engine/graphics/buffer.h

@@ -31,6 +31,7 @@ struct Buffer {
 
     void     upload_data(const void* bufferData, size_t size);
     void     upload_data(const void* bufferData, size_t size, size_t offset);
+    void     copy_to(void* data);
     uint64_t get_device_address();
     void     cleanup();
 };

include/engine/graphics/command_buffer.h

@@ -34,23 +34,16 @@ struct CommandBuffer {
     void begin(VkCommandBufferUsageFlags flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
     void end();
     void reset();
-    void
-    submit(Fence fence = {}, std::vector<Semaphore> waitSemaphores = {}, std::vector<Semaphore> signalSemaphores = {});
+    void submit(Fence fence = {}, std::vector<Semaphore> waitSemaphores = {}, std::vector<Semaphore> signalSemaphores = {});
     void cleanup();
 
     /****************************************** */
     /* COMMANDS */
     /****************************************** */
 
-    void begin_renderpass(RenderPass&       renderpass,
-                          Framebuffer&      fbo,
-                          VkSubpassContents subpassContents = VK_SUBPASS_CONTENTS_INLINE);
+    void begin_renderpass(RenderPass& renderpass, Framebuffer& fbo, VkSubpassContents subpassContents = VK_SUBPASS_CONTENTS_INLINE);
     void end_renderpass(RenderPass& renderpass, Framebuffer& fbo);
-    void draw_geometry(VertexArrays& vao,
-                       uint32_t      instanceCount  = 1,
-                       uint32_t      firstOcurrence = 0,
-                       int32_t       offset         = 0,
-                       uint32_t      firstInstance  = 0);
+    void draw_geometry(VertexArrays& vao, uint32_t instanceCount = 1, uint32_t firstOcurrence = 0, int32_t offset = 0, uint32_t firstInstance = 0);
     void draw_gui_data();
     void bind_shaderpass(ShaderPass& pass);
     void bind_descriptor_set(DescriptorSet         descriptor,
@@ -82,10 +75,7 @@ struct CommandBuffer {
                           PipelineStage srcStage  = STAGE_COLOR_ATTACHMENT_OUTPUT,
                           PipelineStage dstStage  = STAGE_FRAGMENT_SHADER);
 
-    void clear_image(Image&      img,
-                     ImageLayout layout,
-                     ImageAspect aspect     = ASPECT_COLOR,
-                     Vec4        clearColor = Vec4(0.0f, 0.0f, 0.0f, 1.0f));
+    void clear_image(Image& img, ImageLayout layout, ImageAspect aspect = ASPECT_COLOR, Vec4 clearColor = Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 
     /*Copy the entire extent of the image*/
     void blit_image(Image&      srcImage,
@@ -117,13 +107,13 @@ struct CommandBuffer {
     Expected layout is LAYOUT_UNDEFINED
     */
     void copy_buffer_to_image(Image& img, Buffer& buffer);
+    
+    void copy_image_to_buffer(Image& img, Buffer& buffer);
 
     /*
     Generates mipmaps for a given image following a downsampling by 2 strategy
     */
-    void generate_mipmaps(Image&      img,
-                          ImageLayout initialLayout = LAYOUT_TRANSFER_DST_OPTIMAL,
-                          ImageLayout finalLayout   = LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+    void generate_mipmaps(Image& img, ImageLayout initialLayout = LAYOUT_TRANSFER_DST_OPTIMAL, ImageLayout finalLayout = LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 };
 struct CommandPool {
     VkCommandPool handle = VK_NULL_HANDLE;

include/engine/graphics/device.h

@@ -95,6 +95,9 @@ class Device
               uint32_t        framesPerFlight,
               ColorFormatType presentFormat,
               SyncType        presentMode);
+
+    void init_headless();
+
     void update_swapchain(Extent2D surfaceExtent, uint32_t framesPerFlight, ColorFormatType presentFormat, SyncType presentMode);
     void cleanup();
 
@@ -167,12 +170,13 @@ class Device
     void upload_texture_image(Image& img, ImageConfig config, SamplerConfig samplerConfig, const void* imgCache, size_t bytesPerPixel);
     void upload_BLAS(BLAS& accel, VAO& vao);
     void upload_TLAS(TLAS& accel, std::vector<BLASInstance>& BLASinstances);
+    void download_texture_image(Image& img, void*& imgCache, size_t& outSize);
     /*
     MISC
     -----------------------------------------------
     */
-    void     wait();
-    void     wait_queue(QueueType queueType);
+    void     wait_idle();
+    void     wait_queue_idle(QueueType queueType);
     void     init_imgui(void* windowHandle, WindowingSystem windowingSystem, RenderPass renderPass, uint16_t samples);
     void     destroy_imgui();
     uint32_t get_memory_type(uint32_t typeBits, MemoryPropertyFlags properties, uint32_t* memTypeFound = nullptr);

include/engine/graphics/image.h

@@ -52,7 +52,7 @@ struct Image {
     VkSampler       sampler       = VK_NULL_HANDLE;
     VkDescriptorSet GUIReadHandle = VK_NULL_HANDLE;
 
-    /*State parameters*/
+    /*Config parameters*/
     Extent3D    extent        = {0, 0, 1}; // Depth for 3D Textures
     ImageLayout currentLayout = LAYOUT_UNDEFINED;
     uint32_t    layers        = 1; // Layers for Cubemaps and Arrays

include/engine/graphics/swapchain.h

@@ -19,19 +19,17 @@ VULKAN_ENGINE_NAMESPACE_BEGIN
 namespace Graphics {
 class Swapchain
 {
-    VkSwapchainKHR             m_handle;
-    VkDevice                   m_device;
-    VkSurfaceKHR               m_surface;
-    VkFormat                   m_presentFormat;
-    VkPresentModeKHR           m_presentMode;
-    std::vector<Image>         m_presentImages;
+    VkSwapchainKHR     m_handle  = VK_NULL_HANDLE;
+    VkDevice           m_device  = VK_NULL_HANDLE;
+    VkSurfaceKHR       m_surface = VK_NULL_HANDLE;
+    VkFormat           m_presentFormat;
+    VkPresentModeKHR   m_presentMode;
+    std::vector<Image> m_presentImages;
 
     bool m_initialized{false};
 
-    VkSurfaceFormatKHR choose_swap_surface_format(const std::vector<VkSurfaceFormatKHR>& availableFormats,
-                                                  VkFormat                               desiredFormat);
-    VkPresentModeKHR   choose_swap_present_mode(const std::vector<VkPresentModeKHR>& availablePresentModes,
-                                                VkPresentModeKHR                     desiredMode);
+    VkSurfaceFormatKHR choose_swap_surface_format(const std::vector<VkSurfaceFormatKHR>& availableFormats, VkFormat desiredFormat);
+    VkPresentModeKHR   choose_swap_present_mode(const std::vector<VkPresentModeKHR>& availablePresentModes, VkPresentModeKHR desiredMode);
     VkExtent2D         choose_swap_extent(const VkSurfaceCapabilitiesKHR& capabilities, VkExtent2D actualExtent);
 
     void create_image_views(VkDevice& device);

include/engine/graphics/utilities/bootstrap.h

@@ -18,15 +18,12 @@ namespace Graphics {
 namespace Booter {
 #pragma region Instance
 // Instance
-VkInstance create_instance(const char*              appName,
-                           const char*              engineName,
-                           bool                     validation,
-                           std::vector<const char*> validationLayers);
+VkInstance create_instance(const char* appName, const char* engineName, bool validation, std::vector<const char*> validationLayers);
 
 #pragma region Validation
 // Validation Logger
-VkDebugUtilsMessengerEXT create_debug_messenger(VkInstance instance);
-void                     populate_debug_messenger_create_info(VkDebugUtilsMessengerCreateInfoEXT& createInfo);
+VkDebugUtilsMessengerEXT                     create_debug_messenger(VkInstance instance);
+void                                         populate_debug_messenger_create_info(VkDebugUtilsMessengerCreateInfoEXT& createInfo);
 inline static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
                                                            VkDebugUtilsMessageTypeFlagsEXT             messageType,
                                                            const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
@@ -40,15 +37,12 @@ VkResult create_debug_utils_messenger_EXT(VkInstance
                                           const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
                                           const VkAllocationCallbacks*              pAllocator,
                                           VkDebugUtilsMessengerEXT*                 pDebugMessenger);
-void     destroy_debug_utils_messenger_EXT(VkInstance                   instance,
-                                           VkDebugUtilsMessengerEXT     debugMessenger,
-                                           const VkAllocationCallbacks* pAllocator);
+void     destroy_debug_utils_messenger_EXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator);
 #pragma region GPU
 // GPU
-VkPhysicalDevice
-     pick_graphics_card_device(VkInstance instance, VkSurfaceKHR surface, std::vector<const char*> extensions);
-int  rate_device_suitability(VkPhysicalDevice device, VkSurfaceKHR surface, std::vector<const char*> extensions);
-bool check_device_extension_support(VkPhysicalDevice device, std::vector<const char*> extensions);
+VkPhysicalDevice pick_graphics_card_device(VkInstance instance, VkSurfaceKHR surface, std::vector<const char*> extensions);
+int              rate_device_suitability(VkPhysicalDevice device, VkSurfaceKHR surface, std::vector<const char*> extensions);
+bool             check_device_extension_support(VkPhysicalDevice device, std::vector<const char*> extensions);
 struct SwapChainSupportDetails {
     VkSurfaceCapabilitiesKHR        capabilities;
     std::vector<VkSurfaceFormatKHR> formats;
@@ -62,8 +56,10 @@ struct QueueFamilyIndices {
     std::optional<uint32_t> transferFamily;
     std::optional<uint32_t> sparseBindingFamily;
 
-    inline bool isComplete() const {
-        return graphicsFamily.has_value() && presentFamily.has_value() && computeFamily.has_value();
+    inline bool isComplete(bool headless = false) const {
+
+        return !headless ? graphicsFamily.has_value() && presentFamily.has_value() && computeFamily.has_value()
+                         : graphicsFamily.has_value() && computeFamily.has_value();
     }
 };
 QueueFamilyIndices find_queue_families(VkPhysicalDevice device, VkSurfaceKHR surface);

include/engine/systems/renderers/deferred.h

@@ -57,12 +57,14 @@ class DeferredRenderer : public BaseRenderer
     virtual void update_enviroment(Core::Skybox* const skybox);
 
   public:
+    // Headless instantiation
+    DeferredRenderer(Extent2D displayExtent = {800, 800})
+        : BaseRenderer(displayExtent) {
+    }
     DeferredRenderer(Core::IWindow* window)
         : BaseRenderer(window) {
     }
-    DeferredRenderer(Core::IWindow*   window,
-                     ShadowResolution shadowQuality = ShadowResolution::MEDIUM,
-                     RendererSettings settings      = {})
+    DeferredRenderer(Core::IWindow* window, ShadowResolution shadowQuality = ShadowResolution::MEDIUM, RendererSettings settings = {})
         : BaseRenderer(window, settings)
         , m_shadowQuality(shadowQuality) {
     }