-Dev: working on VXGI

Author: AEspinosaDev

examples/sponza/application.cpp

@@ -58,8 +58,6 @@ void Application::setup() {
     m_scene->set_ambient_intensity(0.1f);
     m_scene->use_IBL(false);
 
-   
-
     m_camera = m_scene->get_active_camera();
     m_controller = new Tools::Controller(m_camera, m_window, ControllerMovementType::WASD);
 }

include/engine/core/passes/voxelization_pass.h

@@ -0,0 +1,54 @@
+/*
+    This file is part of Vulkan-Engine, a simple to use Vulkan based 3D library
+
+    MIT License
+
+    Copyright (c) 2023 Antonio Espinosa Garcia
+
+*/
+#ifndef VOXELIZATION_PASS_H
+#define VOXELIZATION_PASS_H
+#include <engine/core/passes/pass.h>
+#include <engine/core/resource_manager.h>
+
+VULKAN_ENGINE_NAMESPACE_BEGIN
+
+namespace Core {
+
+class VoxelizationPass : public GraphicPass
+{
+    Graphics::Image m_voxelization = {};
+
+    /*Descriptors*/
+    struct FrameDescriptors {
+        Graphics::DescriptorSet globalDescritor;
+        Graphics::DescriptorSet objectDescritor;
+    };
+    std::vector<FrameDescriptors> m_descriptors;
+
+    void create_voxelization_image();
+    void setup_material_descriptor(IMaterial* mat);
+
+  public:
+    VoxelizationPass(Graphics::Device* ctx, uint32_t resolution)
+        : BasePass(ctx, {resolution, resolution}, 1, 1, false, "VOXELIZATION") {
+    }
+
+    void setup_attachments(std::vector<Graphics::AttachmentInfo>&    attachments,
+                           std::vector<Graphics::SubPassDependency>& dependencies);
+
+    void setup_uniforms(std::vector<Graphics::Frame>& frames);
+
+    void setup_shader_passes();
+
+    void render(Graphics::Frame& currentFrame, Scene* const scene, uint32_t presentImageIndex = 0);
+
+    void update_uniforms(uint32_t frameIndex, Scene* const scene);
+
+    void cleanup();
+};
+
+} // namespace Core
+VULKAN_ENGINE_NAMESPACE_END
+
+#endif

include/engine/core/scene/mesh.h

@@ -24,30 +24,58 @@ class Mesh;
 /*
 Bounding volume base struct
 */
-struct Volume {
-    Mesh* mesh;
-    Vec3  center{0.0f, 0.0f, 0.0f};
+struct BoundingVolume {
+    const VolumeType TYPE;
+    Object3D*        obj       = nullptr;
+    Vec3             center    = {0.0f, 0.0f, 0.0f};
+    Vec3             maxCoords = {0.0f, 0.0f, 0.0f};
+    Vec3             minCoords = {INFINITY, INFINITY, INFINITY};
+
+    BoundingVolume(VolumeType t, Object3D* o)
+        : TYPE(t)
+        , obj(o) {
+    }
 
     virtual void setup(Mesh* const mesh) = 0;
 
     virtual bool is_on_frustrum(const Frustum& frustum) const = 0;
 };
-struct Sphere : public Volume {
+typedef BoundingVolume BVolume;
+typedef BoundingVolume BV;
+
+struct BoundingSphere : public BVolume {
     float radius{0.0f};
 
-    Sphere() = default;
+    BoundingSphere(Object3D* o)
+        : BVolume(VolumeType::SPHERE_VOLUME, o) {
+    }
 
-    Sphere(const Vec3 c, const float r)
-        : radius(r) {
+    BoundingSphere(const Vec3 c, const float r, Object3D* o)
+        : radius(r)
+        , BVolume(VolumeType::SPHERE_VOLUME, o) {
         center = c;
     }
 
     virtual void setup(Mesh* const mesh);
 
     virtual bool is_on_frustrum(const Frustum& frustum) const;
 };
-struct AABB : public Volume {
-    // TO DO
+struct AABB : public BVolume {
+
+    AABB(Object3D* o)
+        : BVolume(VolumeType::AABB_VOLUME, o) {
+    }
+
+    AABB(const Vec3 min, const Vec3 max, Object3D* o)
+        : BoundingVolume(VolumeType::AABB_VOLUME, o) {
+        minCoords = min;
+        maxCoords = max;
+        center    = (maxCoords + minCoords) * 0.5f;
+    }
+
+    virtual void setup(Mesh* const mesh);
+
+    virtual bool is_on_frustrum(const Frustum& frustum) const;
 };
 
 /*
@@ -59,8 +87,7 @@ class Mesh : public Object3D
     std::vector<Geometry*>  m_geometry;
     std::vector<IMaterial*> m_material;
 
-    VolumeType  m_volumeType     = SPHERE_VOLUME;
-    Volume*     m_volume         = nullptr;
+    BV*         m_volume         = nullptr;
     bool        m_affectedByFog  = true;
     bool        m_castShadows    = true;
     bool        m_receiveShadows = true;
@@ -77,12 +104,12 @@ class Mesh : public Object3D
   public:
     Mesh()
         : Object3D("Mesh #" + std::to_string(Mesh::m_instanceCount), ObjectType::MESH)
-        , m_volume(new Sphere()) {
+        , m_volume(nullptr) {
         Mesh::m_instanceCount++;
     }
     Mesh(Geometry* geom, IMaterial* mat)
         : Object3D("Mesh #" + std::to_string(Mesh::m_instanceCount), ObjectType::MESH)
-        , m_volume(new Sphere()) {
+        , m_volume(nullptr) {
         Mesh::m_instanceCount++;
         m_geometry.push_back(geom);
         m_material.push_back(mat);
@@ -173,17 +200,8 @@ class Mesh : public Object3D
     inline bool ray_hittable() const {
         return m_rayHittable;
     }
-    inline VolumeType get_volume_type() const {
-        return m_volumeType;
-    }
-    void set_volume_type(VolumeType t);
-
-    inline void setup_volume() {
-        if (m_volume)
-            m_volume->setup(this);
-    }
 
-    inline const Volume* const get_bounding_volume() const {
+    inline const BV* const get_bounding_volume() const {
         return m_volume;
     }
 
@@ -202,6 +220,7 @@ class Mesh : public Object3D
         m_geometry[geometrySlot]->set_material_ID(materialSlot);
     }
 
+    void  setup_volume(VolumeType type = VolumeType::SPHERE_VOLUME);
     Mesh* clone() const;
 };
 } // namespace Core

include/engine/core/scene/scene.h

@@ -39,6 +39,8 @@ class Scene : public Object3D
     Vec3  m_fogColor         = {0.2f, 0.2f, 0.2f};
     float m_fogIntensity     = 20.0f;
     float m_fogExponent      = 1.0f;
+    // BVOL
+    AABB m_volume = (this);
 
     inline void classify_object(Object3D* obj) {
         switch (obj->get_type())
@@ -69,7 +71,6 @@ class Scene : public Object3D
     Scene()
         : m_activeCamera(nullptr) {};
     ~Scene() {
-
         delete m_activeCamera;
         delete m_skybox;
 
@@ -176,7 +177,9 @@ class Scene : public Object3D
     inline void update_AS(bool op) {
         m_updateAccel = op;
     }
+    void compute_limits();
 };
+
 void set_meshes(Scene* const scene, std::vector<Mesh*> meshes);
 
 Graphics::TLAS* get_TLAS(Scene* const scene);

include/engine/systems/renderers/deferred.h

@@ -6,6 +6,7 @@
 #include <engine/core/passes/geometry_pass.h>
 #include <engine/core/passes/postprocess_pass.h>
 #include <engine/core/passes/precomposition_pass.h>
+#include <engine/core/passes/voxelization_pass.h>
 #include <engine/core/passes/variance_shadow_pass.h>
 
 #include <engine/systems/renderers/renderer.h>
@@ -21,13 +22,14 @@ class DeferredRenderer : public BaseRenderer
 {
     enum RendererPasses
     {
-        SHADOW_PASS         = 0,
-        GEOMETRY_PASS       = 1,
-        PRECOMPOSITION_PASS = 2,
-        COMPOSITION_PASS    = 3,
-        BLOOM_PASS          = 4,
-        TONEMAPPIN_PASS     = 5,
-        FXAA_PASS           = 6,
+        VOXELIZATION_PASS   = 0,
+        SHADOW_PASS         = 1,
+        GEOMETRY_PASS       = 2,
+        PRECOMPOSITION_PASS = 3,
+        COMPOSITION_PASS    = 4,
+        BLOOM_PASS          = 5,
+        TONEMAPPIN_PASS     = 6,
+        FXAA_PASS           = 7,
     };
 
     ShadowResolution m_shadowQuality = ShadowResolution::MEDIUM;

include/engine/systems/renderers/renderer.h

@@ -48,10 +48,10 @@ class BaseRenderer
   protected:
     Graphics::Device*            m_device;
     std::vector<Graphics::Frame> m_frames;
-
-    Core::IWindow* m_window;
-
+    Core::IWindow*               m_window;
     RendererSettings             m_settings{};
+
+    /*Passes*/
     std::vector<Core::BasePass*> m_passes;
 
     Graphics::Utils::DeletionQueue m_deletionQueue;