Implementing Acceleration Structures

Author: AEspinosaDev

include/engine/common.h

@@ -12,6 +12,8 @@
 #ifdef _WIN32
 // Windows-specific includes and definitions
 #define VK_USE_PLATFORM_WIN32_KHR
+// #include <Volk/volk.h>
+// #define VK_NO_PROTOTYPES
 #define GLFW_INCLUDE_VULKAN
 #include <GLFW/glfw3.h>
 #define GLFW_EXPOSE_NATIVE_WIN32
@@ -540,9 +542,9 @@ typedef enum RenderResult
     THREAD_DONE_KHR                                    = VK_THREAD_DONE_KHR,
     OPERATION_DEFERRED_KHR                             = VK_OPERATION_DEFERRED_KHR,
     OPERATION_NOT_DEFERRED_KHR                         = VK_OPERATION_NOT_DEFERRED_KHR,
-    ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR             = VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR,
+    // ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR             = VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR,
     ERROR_COMPRESSION_EXHAUSTED_EXT                    = VK_ERROR_COMPRESSION_EXHAUSTED_EXT,
-    INCOMPATIBLE_SHADER_BINARY_EXT                     = VK_INCOMPATIBLE_SHADER_BINARY_EXT,
+    // INCOMPATIBLE_SHADER_BINARY_EXT                     = VK_INCOMPATIBLE_SHADER_BINARY_EXT,
     ERROR_OUT_OF_POOL_MEMORY_KHR                       = VK_ERROR_OUT_OF_POOL_MEMORY_KHR,
     ERROR_INVALID_EXTERNAL_HANDLE_KHR                  = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
     ERROR_FRAGMENTATION_EXT                            = VK_ERROR_FRAGMENTATION_EXT,

include/engine/core/geometries/geometry.h

@@ -11,18 +11,17 @@
 #define GEOMETRY_H
 
 #include <engine/common.h>
-#include <engine/graphics/buffer.h>
+#include <engine/graphics/accel.h>
+#include <engine/graphics/vao.h>
 
 VULKAN_ENGINE_NAMESPACE_BEGIN
 
-namespace Core
-{
+namespace Core {
 
 class Geometry;
 
-struct GeometricData
-{
-    std::vector<uint32_t> vertexIndex;
+struct GeometricData {
+    std::vector<uint32_t>                vertexIndex;
     std::vector<Graphics::Utils::Vertex> vertexData;
 
     // Stats
@@ -35,7 +34,6 @@ struct GeometricData
     void compute_statistics();
 };
 
-
 /*
 Class that defines the mesh geometry. Can be setup by filling it with a canonical vertex type array.
 */
@@ -44,55 +42,49 @@ class Geometry
 
   private:
     Graphics::VertexArrays m_VAO{};
-    GeometricData m_geometryData{};
+    Graphics::BLAS         m_BLAS{};
+    GeometricData          m_geometryData{};
 
     size_t m_materialID{0};
 
-    friend  Graphics::VertexArrays *const get_render_data(Geometry *g);
+    friend Graphics::VertexArrays* const get_VAO(Geometry* g);
+    friend Graphics::BLAS* const get_BLAS(Geometry* g);
 
   public:
-    Geometry()
-    {
+    Geometry() {
     }
 
-    inline size_t get_material_ID() const
-    {
+    inline size_t get_material_ID() const {
         return m_materialID;
     }
-    inline void set_material_ID(size_t id)
-    {
+    inline void set_material_ID(size_t id) {
         m_materialID = id;
     }
 
-    inline bool data_loaded() const
-    {
+    inline bool data_loaded() const {
         return m_geometryData.loaded;
     }
-    inline bool indexed() const
-    {
+    inline bool indexed() const {
         return !m_geometryData.vertexIndex.empty();
     }
 
-    inline const GeometricData *get_geometric_data() const
-    {
+    inline const GeometricData* get_geometric_data() const {
         return &m_geometryData;
     }
-    ~Geometry()
-    {
+    ~Geometry() {
     }
 
-    void fill(std::vector<Graphics::Utils::Vertex> vertexInfo);
-    void fill(std::vector<Graphics::Utils::Vertex> vertexInfo, std::vector<uint32_t> vertexIndex);
-    void fill(Vec3 *pos, Vec3 *normal, Vec2 *uv, Vec3 *tangent, uint32_t vertNumber);
-    static Geometry *create_quad();
-    static Geometry *create_cube();
+    void             fill(std::vector<Graphics::Utils::Vertex> vertexInfo);
+    void             fill(std::vector<Graphics::Utils::Vertex> vertexInfo, std::vector<uint32_t> vertexIndex);
+    void             fill(Vec3* pos, Vec3* normal, Vec2* uv, Vec3* tangent, uint32_t vertNumber);
+    static Geometry* create_quad();
+    static Geometry* create_cube();
 };
 
- Graphics::VertexArrays *const get_render_data(Geometry *g);
+Graphics::VertexArrays* const get_VAO(Geometry* g);
 
 } // namespace Core
 
 VULKAN_ENGINE_NAMESPACE_END;
 
-
 #endif // VK_GEOMETRY_H

include/engine/core/materials/hair_strand.h

@@ -26,13 +26,13 @@ class HairStrandMaterial : public IMaterial
     float m_thickness{0.003f};
 
     bool  m_R{true}; // Reflection
-    float m_Rpower{4.0f};
+    float m_Rpower{1.0f};
 
     bool  m_TT{true}; // Transmitance
-    float m_TTpower{5.0f};
+    float m_TTpower{1.0f};
 
     bool  m_TRT{true}; // Second reflection
-    float m_TRTpower{10.0f};
+    float m_TRTpower{3.0f};
 
     float m_roughness{0.4f};
     float m_scatter{500.0f};

include/engine/graphics/accel.h

@@ -0,0 +1,57 @@
+/*
+    This file is part of Vulkan-Engine, a simple to use Vulkan based 3D library
+
+    MIT License
+
+    Copyright (c) 2023 Antonio Espinosa Garcia
+
+*/
+#ifndef ACCEL_H
+#define ACCEL_H
+
+#include <engine/common.h>
+#include <engine/graphics/utilities/initializers.h>
+#include <engine/graphics/extensions.h>
+#include <engine/graphics/vao.h>
+
+VULKAN_ENGINE_NAMESPACE_BEGIN
+
+namespace Graphics {
+/*
+Bottom Level Acceleration structure
+*/
+struct BLAS {
+    VkAccelerationStructureKHR handle       = VK_NULL_HANDLE;
+    VkDevice                   device       = VK_NULL_HANDLE;
+    VkDeviceAddress            deviceAdress = 0;
+
+    Buffer                     buffer       = {};
+
+  public:
+    BLAS() {
+    }
+
+    void cleanup();
+};
+/*
+Top Level Acceleration structure
+*/
+struct TLAS {
+    VkAccelerationStructureKHR handle       = VK_NULL_HANDLE;
+    VkDevice                   device       = VK_NULL_HANDLE;
+    VkDeviceAddress            deviceAdress = 0;
+
+    Buffer                     buffer       = {};
+
+  public:
+    TLAS() {
+    }
+
+    void cleanup();
+};
+
+} // namespace Graphics
+
+VULKAN_ENGINE_NAMESPACE_END
+
+#endif

include/engine/graphics/buffer.h

@@ -15,50 +15,38 @@ VULKAN_ENGINE_NAMESPACE_BEGIN
 
 namespace Graphics {
 // Vulkan buffer object
-class Buffer
-{
-    VkBuffer m_handle;
+struct Buffer {
+    VkBuffer handle = VK_NULL_HANDLE;
     /*Memory allocation controlled by VMA*/
-    VmaAllocator  m_memory;
-    VmaAllocation m_allocation;
+    VmaAllocator          memory     = VK_NULL_HANDLE;
+    VmaAllocation         allocation = VK_NULL_HANDLE;
+    uint32_t              size       = 0;
+    uint32_t              strideSize = 0;
+    std::vector<uint32_t> partitionsSize;
 
-    uint32_t              m_strideSize{0};
-    std::vector<uint32_t> m_partitionsSizes;
-
-  public:
-    inline VkBuffer get_handle() const {
-        return m_handle;
-    }
-    inline uint32_t get_stride_size() const {
-        return m_strideSize;
+    Buffer() {
     }
-    Buffer() {}
 
-    void init(VmaAllocator& memory, size_t allocSize, VkBufferUsageFlags usage, VmaMemoryUsage memoryUsage,
-              uint32_t istrideSize = 0);
-    void init(VmaAllocator& memory, size_t allocSize, VkBufferUsageFlags usage, VmaMemoryUsage memoryUsage,
-              uint32_t istrideSize, std::vector<uint32_t> stridePartitionsSizes);
+    void init(VmaAllocator&      _memory,
+              size_t             allocSize,
+              VkBufferUsageFlags usage,
+              VmaMemoryUsage     memoryUsage,
+              uint32_t           istrideSize = 0);
+    void init(VmaAllocator&         _memory,
+              size_t                allocSize,
+              VkBufferUsageFlags    usage,
+              VmaMemoryUsage        memoryUsage,
+              uint32_t              istrideSize,
+              std::vector<uint32_t> stridePartitionsSizes);
 
     void upload_data(const void* bufferData, size_t size);
 
     void upload_data(const void* bufferData, size_t size, size_t offset);
 
     void cleanup();
-};
-
-/*
-Geometric Render Data
-*/
-struct VertexArrays {
-    bool loadedOnGPU{false};
-
-    Buffer vbo{};
-    Buffer ibo{};
 
-    uint32_t vertexCount{0};
-    uint32_t indexCount{0};
+    uint64_t get_device_address(VkDevice device);
 };
-typedef VertexArrays VAO;
 
 } // namespace Graphics
 

include/engine/graphics/command_buffer.h

@@ -16,6 +16,7 @@
 #include <engine/graphics/utilities/initializers.h>
 #include <engine/graphics/vk_renderpass.h>
 #include <engine/graphics/semaphore.h>
+#include <engine/graphics/vao.h>
 
 VULKAN_ENGINE_NAMESPACE_BEGIN
 
@@ -48,7 +49,7 @@ class CommandBuffer
                 std::vector<Semaphore> waitSemaphores   = {},
                 std::vector<Semaphore> signalSemaphores = {});
 
-    VkCommandBuffer get_handle() const {
+    VkCommandBuffer& get_handle()  {
         return m_handle;
     }
 
@@ -89,7 +90,7 @@ class CommandPool
     CommandPool() {
     }
 
-    inline VkCommandPool get_handle() const {
+    inline VkCommandPool& get_handle() {
         return m_handle;
     }
 

include/engine/graphics/descriptors.h

@@ -48,7 +48,7 @@ class DescriptorPool
     std::unordered_map<uint32_t, VkDescriptorSetLayout> m_layouts;
 
   public:
-    inline VkDescriptorPool get_handle() const {
+    inline VkDescriptorPool& get_handle()  {
         return m_handle;
     }
     void init(VkDevice                       dvc,

include/engine/graphics/device.h

@@ -11,6 +11,7 @@
 
 #include <engine/common.h>
 
+#include <engine/graphics/accel.h>
 #include <engine/graphics/command_buffer.h>
 #include <engine/graphics/extensions.h>
 #include <engine/graphics/frame.h>
@@ -57,19 +58,19 @@ class Device
     GETTERS
     -----------------------------------------------
     */
-    inline VkDevice get_handle() const {
+    inline VkDevice& get_handle() {
         return m_handle;
     };
-    inline VmaAllocator get_memory_allocator() const {
+    inline VmaAllocator& get_memory_allocator() {
         return m_memory;
     }
-    inline VkPhysicalDevice get_GPU() const {
+    inline VkPhysicalDevice& get_GPU() {
         return m_gpu;
     }
     inline Swapchain get_swapchain() const {
         return m_swapchain;
     }
-    inline std::unordered_map<QueueType, VkQueue> get_queues() const {
+    inline std::unordered_map<QueueType, VkQueue>& get_queues() {
         return m_queues;
     }
 
@@ -124,6 +125,9 @@ class Device
                             std::vector<Attachment>& attachments,
                             uint32_t                 layers = 1);
 
+    void create_BLAS(BLAS& accel, VertexArrays& vao);
+    void create_TLAS(TLAS& accel, std::vector<BLAS>& blases);
+
     /*
     DRAWING
     -----------------------------------------------

include/engine/graphics/extensions.h

@@ -21,9 +21,15 @@ DECLARATION OF FUNCTION POINTERS RELATED TO VULKAN EXTENSIONS
 #include <engine/common.h>
 
 // Global function pointers
-extern PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamples;
-extern PFN_vkCmdSetPolygonModeEXT          vkCmdSetPolygonMode;
-
-void load_EXT_functions(VkDevice& device);
+extern PFN_vkCmdSetRasterizationSamplesEXT            vkCmdSetRasterizationSamples;
+extern PFN_vkCmdSetPolygonModeEXT                     vkCmdSetPolygonMode;
+extern PFN_vkCreateAccelerationStructureKHR           vkCreateAccelerationStructure;
+extern PFN_vkDestroyAccelerationStructureKHR          vkDestroyAccelerationStructure;
+extern PFN_vkGetAccelerationStructureBuildSizesKHR    vkGetAccelerationStructureBuildSizes;
+extern PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddress;
+extern PFN_vkCmdBuildAccelerationStructuresKHR        vkCmdBuildAccelerationStructures;
+extern PFN_vkBuildAccelerationStructuresKHR           vkBuildAccelerationStructures;
+
+void load_extensions(VkDevice& device);
 
 #endif

include/engine/graphics/framebuffer.h

@@ -27,7 +27,7 @@ class Framebuffer
     Framebuffer() {
     }
 
-    inline VkFramebuffer get_handle() const {
+    inline VkFramebuffer& get_handle()  {
         return m_handle;
     }