diff --git a/config/Sources.cmake b/config/Sources.cmake
index 4397e4978eb022d267571d185a1f122d053a5ea1..54bb3485ed975669668d987787975f019aa6358b 100644
--- a/config/Sources.cmake
+++ b/config/Sources.cmake
@@ -80,4 +80,7 @@ set(vkcv_sources
${vkcv_source}/vkcv/CommandStreamManager.cpp
${vkcv_include}/vkcv/CommandRecordingFunctionTypes.hpp
+
+ ${vkcv_include}/vkcv/ImageConfig.hpp
+ ${vkcv_source}/vkcv/ImageConfig.cpp
)
diff --git a/include/vkcv/Core.hpp b/include/vkcv/Core.hpp
index 493534f77a0f930cbd0d292a504300f51ebc0f76..cbbe1e908cdb74891ab9bfe4416c03e487e76b26 100644
--- a/include/vkcv/Core.hpp
+++ b/include/vkcv/Core.hpp
@@ -78,8 +78,6 @@ namespace vkcv
event_handle<int,int> e_resizeHandle;
- static std::vector<vk::ImageView> createSwapchainImageViews( Context &context, Swapchain& swapChain);
-
public:
/**
* Destructor of #Core destroys the Vulkan objects contained in the core's context.
@@ -215,13 +213,14 @@ namespace vkcv
*/
[[nodiscard]]
Image createImage(
- vk::Format format,
- uint32_t width,
- uint32_t height,
- uint32_t depth = 1,
- bool createMipChain = false,
- bool supportStorage = false,
- bool supportColorAttachment = false);
+ vk::Format format,
+ uint32_t width,
+ uint32_t height,
+ uint32_t depth = 1,
+ bool createMipChain = false,
+ bool supportStorage = false,
+ bool supportColorAttachment = false,
+ Multisampling multisampling = Multisampling::None);
[[nodiscard]]
const uint32_t getImageWidth(ImageHandle imageHandle);
@@ -290,7 +289,8 @@ namespace vkcv
void prepareImageForStorage(const CommandStreamHandle cmdStream, const ImageHandle image);
void recordImageMemoryBarrier(const CommandStreamHandle cmdStream, const ImageHandle image);
void recordBufferMemoryBarrier(const CommandStreamHandle cmdStream, const BufferHandle buffer);
-
+ void resolveMSAAImage(CommandStreamHandle cmdStream, ImageHandle src, ImageHandle dst);
+
vk::ImageView getSwapchainImageView() const;
};
diff --git a/include/vkcv/DrawcallRecording.hpp b/include/vkcv/DrawcallRecording.hpp
index 0929ad038fb95ec1573e7c76e5ce13adb84ab760..9f162a499a38d5633703f70eec8a8682e3328d72 100644
--- a/include/vkcv/DrawcallRecording.hpp
+++ b/include/vkcv/DrawcallRecording.hpp
@@ -37,11 +37,12 @@ namespace vkcv {
};
struct DrawcallInfo {
- inline DrawcallInfo(const Mesh& mesh, const std::vector<DescriptorSetUsage>& descriptorSets)
- : mesh(mesh), descriptorSets(descriptorSets) {}
+ inline DrawcallInfo(const Mesh& mesh, const std::vector<DescriptorSetUsage>& descriptorSets, const uint32_t instanceCount = 1)
+ : mesh(mesh), descriptorSets(descriptorSets), instanceCount(instanceCount){}
Mesh mesh;
std::vector<DescriptorSetUsage> descriptorSets;
+ uint32_t instanceCount;
};
void recordDrawcall(
diff --git a/include/vkcv/Image.hpp b/include/vkcv/Image.hpp
index eac96975886a92e0043bbb97cbe64f76943efa7e..85ab2b81e2718b3890ba361c988d5db0e40e84c7 100644
--- a/include/vkcv/Image.hpp
+++ b/include/vkcv/Image.hpp
@@ -7,11 +7,11 @@
#include "vulkan/vulkan.hpp"
#include "Handles.hpp"
+#include "vkcv/ImageConfig.hpp"
namespace vkcv {
-
- // forward declares
- class ImageManager;
+
+ class ImageManager;
bool isDepthFormat(const vk::Format format);
@@ -50,15 +50,16 @@ namespace vkcv {
Image(ImageManager* manager, const ImageHandle& handle);
static Image create(
- ImageManager* manager,
- vk::Format format,
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- uint32_t mipCount,
- bool supportStorage,
- bool supportColorAttachment);
-
+ ImageManager* manager,
+ vk::Format format,
+ uint32_t width,
+ uint32_t height,
+ uint32_t depth,
+ uint32_t mipCount,
+ bool supportStorage,
+ bool supportColorAttachment,
+ Multisampling msaa);
+
};
}
diff --git a/include/vkcv/ImageConfig.hpp b/include/vkcv/ImageConfig.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2e413b97be92ae771ef85342981ea0163a93ab52
--- /dev/null
+++ b/include/vkcv/ImageConfig.hpp
@@ -0,0 +1,9 @@
+#pragma once
+#include <vulkan/vulkan.hpp>
+
+namespace vkcv {
+ enum class Multisampling { None, MSAA2X, MSAA4X, MSAA8X };
+
+ vk::SampleCountFlagBits msaaToVkSampleCountFlag(Multisampling msaa);
+ uint32_t msaaToSampleCount(Multisampling msaa);
+}
diff --git a/include/vkcv/PassConfig.hpp b/include/vkcv/PassConfig.hpp
index 8f3b516d4b4451c513366fbd8469908bccde6a5f..f3b2b802d062a441dfb0c810154205effb7053a2 100644
--- a/include/vkcv/PassConfig.hpp
+++ b/include/vkcv/PassConfig.hpp
@@ -2,6 +2,7 @@
#include <vector>
#include <vulkan/vulkan.hpp>
+#include "ImageConfig.hpp"
namespace vkcv
{
@@ -45,7 +46,8 @@ namespace vkcv
struct PassConfig
{
- explicit PassConfig(std::vector<AttachmentDescription> attachments) noexcept;
+ explicit PassConfig(std::vector<AttachmentDescription> attachments, Multisampling msaa = Multisampling::None) noexcept;
std::vector<AttachmentDescription> attachments{};
+ Multisampling msaa;
};
}
\ No newline at end of file
diff --git a/include/vkcv/PipelineConfig.hpp b/include/vkcv/PipelineConfig.hpp
index 1e00c5209118469a7dc6ff1eb1e3c98a3c6903a7..5e6dbaa3306f8d2aa6fc44d7dd1fadd9b79be3b4 100644
--- a/include/vkcv/PipelineConfig.hpp
+++ b/include/vkcv/PipelineConfig.hpp
@@ -10,21 +10,35 @@
#include "Handles.hpp"
#include "ShaderProgram.hpp"
#include "VertexLayout.hpp"
+#include "ImageConfig.hpp"
namespace vkcv {
enum class PrimitiveTopology{PointList, LineList, TriangleList };
+ enum class CullMode{ None, Front, Back };
+ enum class DepthTest { None, Less, LessEqual, Greater, GreatherEqual, Equal };
+
+ // add more as needed
+ // alternatively we could expose the blend factors directly
+ enum class BlendMode{ None, Additive };
struct PipelineConfig {
- ShaderProgram m_ShaderProgram;
- uint32_t m_Width;
- uint32_t m_Height;
- PassHandle m_PassHandle;
- VertexLayout m_VertexLayout;
- std::vector<vk::DescriptorSetLayout> m_DescriptorLayouts;
- bool m_UseDynamicViewport;
- bool m_UseConservativeRasterization = false;
- PrimitiveTopology m_PrimitiveTopology = PrimitiveTopology::TriangleList;
+ ShaderProgram m_ShaderProgram;
+ uint32_t m_Width;
+ uint32_t m_Height;
+ PassHandle m_PassHandle;
+ VertexLayout m_VertexLayout;
+ std::vector<vk::DescriptorSetLayout> m_DescriptorLayouts;
+ bool m_UseDynamicViewport;
+ bool m_UseConservativeRasterization = false;
+ PrimitiveTopology m_PrimitiveTopology = PrimitiveTopology::TriangleList;
+ BlendMode m_blendMode = BlendMode::None;
+ bool m_EnableDepthClamping = false;
+ Multisampling m_multisampling = Multisampling::None;
+ CullMode m_culling = CullMode::None;
+ DepthTest m_depthTest = DepthTest::LessEqual;
+ bool m_depthWrite = true;
+ bool m_alphaToCoverage = false;
};
}
\ No newline at end of file
diff --git a/include/vkcv/Swapchain.hpp b/include/vkcv/Swapchain.hpp
index b75fc5a87156ea56061e41b4b0974928c83ffa28..5e9bc7d0593a3b2e1f1f8e7b5ef7ea69e9711fb5 100644
--- a/include/vkcv/Swapchain.hpp
+++ b/include/vkcv/Swapchain.hpp
@@ -7,6 +7,9 @@
namespace vkcv
{
+
+ const uint32_t MIN_SWAPCHAIN_SIZE = 2;
+
class Swapchain final {
private:
friend class Core;
@@ -119,4 +122,5 @@ namespace vkcv
const vk::Extent2D& getExtent() const;
};
+
}
diff --git a/include/vkcv/Window.hpp b/include/vkcv/Window.hpp
index 7dc6c1b7dc8fef4d5de7de5b0a9976bf714e6ac2..f3b3a8fe88ae6e8791d7d92361ad5b6bf2447dcb 100644
--- a/include/vkcv/Window.hpp
+++ b/include/vkcv/Window.hpp
@@ -157,6 +157,13 @@ namespace vkcv {
* Destructor of #Window, terminates GLFW
*/
virtual ~Window();
+
+ /**
+ * gets the windows framebuffer size
+ * @param width
+ * @param height
+ */
+ void getFramebufferSize(int& width, int& height) const;
};
}
diff --git a/modules/asset_loader/include/vkcv/asset/asset_loader.hpp b/modules/asset_loader/include/vkcv/asset/asset_loader.hpp
index 4107d57ee97a6efe0475c6d9dbd80d2603e0afe8..471870fb1e5af3d3c448a66611d9754db9597f85 100644
--- a/modules/asset_loader/include/vkcv/asset/asset_loader.hpp
+++ b/modules/asset_loader/include/vkcv/asset/asset_loader.hpp
@@ -9,6 +9,7 @@
#include <vector>
#include <array>
#include <cstdint>
+#include <filesystem>
/** These macros define limits of the following structs. Implementations can
* test against these limits when performing sanity checks. The main constraint
@@ -114,7 +115,8 @@ enum class PrimitiveType : uint32_t {
POSITION = 1,
NORMAL = 2,
TEXCOORD_0 = 3,
- TEXCOORD_1 = 4
+ TEXCOORD_1 = 4,
+ TANGENT = 5
};
/** These integer values are used the same way in OpenGL, Vulkan and glTF. This
@@ -189,5 +191,12 @@ typedef struct {
* */
int loadScene(const std::string &path, Scene &scene);
+struct TextureData {
+ int width;
+ int height;
+ int componentCount;
+ std::vector<char*> data;
+};
+TextureData loadTexture(const std::filesystem::path& path);
}
diff --git a/modules/asset_loader/src/vkcv/asset/asset_loader.cpp b/modules/asset_loader/src/vkcv/asset/asset_loader.cpp
index c21d0c9f70bc81561e1078b15b8372e6dd4730f5..e3d3072543bd33e1f5a67ae7dac61d229005947a 100644
--- a/modules/asset_loader/src/vkcv/asset/asset_loader.cpp
+++ b/modules/asset_loader/src/vkcv/asset/asset_loader.cpp
@@ -63,8 +63,7 @@ enum IndexType getIndexType(const enum fx::gltf::Accessor::ComponentType &t)
case fx::gltf::Accessor::ComponentType::UnsignedInt:
return IndexType::UINT32;
default:
- std::cerr << "ERROR: Index type not supported: " <<
- static_cast<uint16_t>(t) << std::endl;
+ vkcv_log(LogLevel::ERROR, "Index type not supported: %u", static_cast<uint16_t>(t));
return IndexType::UNDEFINED;
}
}
@@ -174,8 +173,11 @@ int loadScene(const std::string &path, Scene &scene){
attribute.type = PrimitiveType::NORMAL;
} else if (attrib.first == "TEXCOORD_0") {
attribute.type = PrimitiveType::TEXCOORD_0;
- } else if (attrib.first == "TEXCOORD_1") {
+ }
+ else if (attrib.first == "TEXCOORD_1") {
attribute.type = PrimitiveType::TEXCOORD_1;
+ } else if (attrib.first == "TANGENT") {
+ attribute.type = PrimitiveType::TANGENT;
} else {
return 0;
}
@@ -363,4 +365,23 @@ int loadScene(const std::string &path, Scene &scene){
return 1;
}
+TextureData loadTexture(const std::filesystem::path& path) {
+ TextureData texture;
+
+ uint8_t* data = stbi_load(path.string().c_str(), &texture.width, &texture.height, &texture.componentCount, 4);
+
+ if (!data) {
+ vkcv_log(LogLevel::ERROR, "Texture could not be loaded from '%s'", path.c_str());
+
+ texture.width = 0;
+ texture.height = 0;
+ texture.componentCount = 0;
+ return texture;
+ }
+
+ texture.data.resize(texture.width * texture.height * 4);
+ memcpy(texture.data.data(), data, texture.data.size());
+ return texture;
+}
+
}
diff --git a/modules/camera/include/vkcv/camera/Camera.hpp b/modules/camera/include/vkcv/camera/Camera.hpp
index ce32d3f8a0c6ee3e0dd882f24a9ac2d12c14a024..9d85df7dce6d043630fd9d39287cace8530dbd6a 100644
--- a/modules/camera/include/vkcv/camera/Camera.hpp
+++ b/modules/camera/include/vkcv/camera/Camera.hpp
@@ -75,7 +75,7 @@ namespace vkcv::camera {
* @brief Gets the current projection of the camera
* @return The current projection matrix
*/
- const glm::mat4& getProjection() const;
+ glm::mat4 getProjection() const;
/**
* @brief Gets the model-view-projection matrix of the camera with y-axis-correction applied
diff --git a/modules/camera/src/vkcv/camera/Camera.cpp b/modules/camera/src/vkcv/camera/Camera.cpp
index 18bf94463a0e2c4cb7d64526f4c30835cb451eb2..3541b1a5bc1253c6b0f2b044d757341855a5e900 100644
--- a/modules/camera/src/vkcv/camera/Camera.cpp
+++ b/modules/camera/src/vkcv/camera/Camera.cpp
@@ -37,22 +37,22 @@ namespace vkcv::camera {
m_view = view;
}
- const glm::mat4& Camera::getProjection() const {
- return m_projection;
+ const glm::mat4 y_correction(
+ 1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, -1.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 1.0f
+ );
+
+ glm::mat4 Camera::getProjection() const {
+ return y_correction * m_projection;
}
void Camera::setProjection(const glm::mat4& projection) {
- m_projection = projection;
+ m_projection = glm::inverse(y_correction) * projection;
}
glm::mat4 Camera::getMVP() const {
- const glm::mat4 y_correction (
- 1.0f, 0.0f, 0.0f, 0.0f,
- 0.0f, -1.0f, 0.0f, 0.0f,
- 0.0f, 0.0f, 1.0f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f
- );
-
return y_correction * m_projection * m_view;
}
diff --git a/projects/CMakeLists.txt b/projects/CMakeLists.txt
index 34fbcb0cf8dd3f1d34efd2cc8424994c7da76e32..1c6e3afe2347f6ef8ea8a62be7acbe0ea750497d 100644
--- a/projects/CMakeLists.txt
+++ b/projects/CMakeLists.txt
@@ -3,5 +3,6 @@
add_subdirectory(bloom)
add_subdirectory(first_triangle)
add_subdirectory(first_mesh)
+add_subdirectory(particle_simulation)
add_subdirectory(first_scene)
-add_subdirectory(voxelization)
\ No newline at end of file
+add_subdirectory(voxelization)
diff --git a/projects/cmd_sync_test/src/main.cpp b/projects/cmd_sync_test/src/main.cpp
index eccc0af7331dc140f3a15ddf12c5645e685abc90..6e53eb8c5ec1825135778dc91b11dd6e45f44276 100644
--- a/projects/cmd_sync_test/src/main.cpp
+++ b/projects/cmd_sync_test/src/main.cpp
@@ -175,8 +175,8 @@ int main(int argc, const char** argv) {
std::vector<vkcv::DrawcallInfo> shadowDrawcalls;
for (const auto& position : instancePositions) {
modelMatrices.push_back(glm::translate(glm::mat4(1.f), position));
- drawcalls.push_back(vkcv::DrawcallInfo(loadedMesh, { descriptorUsage }));
- shadowDrawcalls.push_back(vkcv::DrawcallInfo(loadedMesh, {}));
+ drawcalls.push_back(vkcv::DrawcallInfo(loadedMesh, { descriptorUsage },1));
+ shadowDrawcalls.push_back(vkcv::DrawcallInfo(loadedMesh, {},1));
}
modelMatrices.back() *= glm::scale(glm::mat4(1.f), glm::vec3(10.f, 1.f, 10.f));
diff --git a/projects/first_mesh/src/main.cpp b/projects/first_mesh/src/main.cpp
index dc43c905784525a34732bc0e66343fbdcc17a639..e7546fc3a143b3638cceb36869c519336ebec751 100644
--- a/projects/first_mesh/src/main.cpp
+++ b/projects/first_mesh/src/main.cpp
@@ -83,6 +83,7 @@ int main(int argc, const char** argv) {
firstMeshProgram.addShader(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/frag.spv"));
auto& attributes = mesh.vertexGroups[0].vertexBuffer.attributes;
+
std::sort(attributes.begin(), attributes.end(), [](const vkcv::asset::VertexAttribute& x, const vkcv::asset::VertexAttribute& y) {
return static_cast<uint32_t>(x.type) < static_cast<uint32_t>(y.type);
@@ -149,7 +150,7 @@ int main(int argc, const char** argv) {
const vkcv::Mesh renderMesh(vertexBufferBindings, indexBuffer.getVulkanHandle(), mesh.vertexGroups[0].numIndices);
vkcv::DescriptorSetUsage descriptorUsage(0, core.getDescriptorSet(descriptorSet).vulkanHandle);
- vkcv::DrawcallInfo drawcall(renderMesh, { descriptorUsage });
+ vkcv::DrawcallInfo drawcall(renderMesh, { descriptorUsage },1);
vkcv::camera::CameraManager cameraManager(window);
uint32_t camIndex0 = cameraManager.addCamera(vkcv::camera::ControllerType::PILOT);
diff --git a/projects/first_scene/src/main.cpp b/projects/first_scene/src/main.cpp
index 420400cdd04865ddd48eec7cf6000e36417d8095..521818732f7a60eabe9f0c2c080c6d343a71b1d8 100644
--- a/projects/first_scene/src/main.cpp
+++ b/projects/first_scene/src/main.cpp
@@ -199,7 +199,7 @@ int main(int argc, const char** argv) {
vkcv::DescriptorSetUsage descriptorUsage(0, core.getDescriptorSet(descriptorSets[i]).vulkanHandle);
- drawcalls.push_back(vkcv::DrawcallInfo(renderMesh, {descriptorUsage}));
+ drawcalls.push_back(vkcv::DrawcallInfo(renderMesh, {descriptorUsage},1));
}
std::vector<glm::mat4> modelMatrices;
diff --git a/projects/first_triangle/src/main.cpp b/projects/first_triangle/src/main.cpp
index 20cfdddf5c1baa9e8727312daa36de94bd56672f..5bdd55a263f4d81d8f424c056d7d6c0b54ccb1ca 100644
--- a/projects/first_triangle/src/main.cpp
+++ b/projects/first_triangle/src/main.cpp
@@ -167,7 +167,7 @@ int main(int argc, const char** argv) {
vkcv::ImageHandle swapchainImageHandle = vkcv::ImageHandle::createSwapchainImageHandle();
const vkcv::Mesh renderMesh({}, triangleIndexBuffer.getVulkanHandle(), 3);
- vkcv::DrawcallInfo drawcall(renderMesh, {});
+ vkcv::DrawcallInfo drawcall(renderMesh, {},1);
const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
diff --git a/projects/particle_simulation/.gitignore b/projects/particle_simulation/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..4964f89e973f38358aa57f564f56d3d4b0c328a9
--- /dev/null
+++ b/projects/particle_simulation/.gitignore
@@ -0,0 +1 @@
+particle_simulation
\ No newline at end of file
diff --git a/projects/particle_simulation/CMakeLists.txt b/projects/particle_simulation/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2a665202c521ac10ae94905cb7580205e897eef9
--- /dev/null
+++ b/projects/particle_simulation/CMakeLists.txt
@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.16)
+project(particle_simulation)
+
+# setting c++ standard for the project
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# this should fix the execution path to load local files from the project
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+# adding source files to the project
+add_executable(particle_simulation
+ src/main.cpp
+ src/ParticleSystem.hpp
+ src/ParticleSystem.cpp
+ src/Particle.hpp
+ src/Particle.cpp
+ src/BloomAndFlares.hpp
+ src/BloomAndFlares.cpp)
+
+# this should fix the execution path to load local files from the project (for MSVC)
+if(MSVC)
+ set_target_properties(particle_simulation PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+ set_target_properties(particle_simulation PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+
+ # in addition to setting the output directory, the working directory has to be set
+ # by default visual studio sets the working directory to the build directory, when using the debugger
+ set_target_properties(particle_simulation PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+endif()
+
+# including headers of dependencies and the VkCV framework
+target_include_directories(particle_simulation SYSTEM BEFORE PRIVATE ${vkcv_include} ${vkcv_includes} ${vkcv_testing_include} ${vkcv_camera_include} ${vkcv_shader_compiler_include})
+
+# linking with libraries from all dependencies and the VkCV framework
+target_link_libraries(particle_simulation vkcv vkcv_testing vkcv_camera vkcv_shader_compiler)
diff --git a/projects/particle_simulation/shaders/bloom/composite.comp b/projects/particle_simulation/shaders/bloom/composite.comp
new file mode 100644
index 0000000000000000000000000000000000000000..87b5ddb975106232d1cd3b6e5b8dc7e623dd0b59
--- /dev/null
+++ b/projects/particle_simulation/shaders/bloom/composite.comp
@@ -0,0 +1,38 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(set=0, binding=0) uniform texture2D blurImage;
+layout(set=0, binding=1) uniform texture2D lensImage;
+layout(set=0, binding=2) uniform sampler linearSampler;
+layout(set=0, binding=3, r11f_g11f_b10f) uniform image2D colorBuffer;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+
+void main()
+{
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(colorBuffer)))){
+ return;
+ }
+
+ ivec2 pixel_coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 pixel_size = vec2(1.0f) / textureSize(sampler2D(blurImage, linearSampler), 0);
+ vec2 UV = pixel_coord.xy * pixel_size;
+
+ vec4 composite_color = vec4(0.0f);
+
+ vec3 blur_color = texture(sampler2D(blurImage, linearSampler), UV).rgb;
+ vec3 lens_color = texture(sampler2D(lensImage, linearSampler), UV).rgb;
+ vec3 main_color = imageLoad(colorBuffer, pixel_coord).rgb;
+
+ // composite blur and lens features
+ float bloom_weight = 0.01f;
+ float lens_weight = 0.f;
+ float main_weight = 1 - (bloom_weight + lens_weight);
+
+ composite_color.rgb = blur_color * bloom_weight +
+ lens_color * lens_weight +
+ main_color * main_weight;
+
+ imageStore(colorBuffer, pixel_coord, composite_color);
+}
\ No newline at end of file
diff --git a/projects/particle_simulation/shaders/bloom/downsample.comp b/projects/particle_simulation/shaders/bloom/downsample.comp
new file mode 100644
index 0000000000000000000000000000000000000000..2ab00c7c92798769153634f3479c5b7f3fb61d94
--- /dev/null
+++ b/projects/particle_simulation/shaders/bloom/downsample.comp
@@ -0,0 +1,76 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(set=0, binding=0) uniform texture2D inBlurImage;
+layout(set=0, binding=1) uniform sampler inImageSampler;
+layout(set=0, binding=2, r11f_g11f_b10f) uniform writeonly image2D outBlurImage;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+
+void main()
+{
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outBlurImage)))){
+ return;
+ }
+
+ ivec2 pixel_coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 pixel_size = vec2(1.0f) / imageSize(outBlurImage);
+ vec2 UV = pixel_coord.xy * pixel_size;
+ vec2 UV_offset = UV + 0.5f * pixel_size;
+
+ vec2 color_fetches[13] = {
+ // center neighbourhood (RED)
+ vec2(-1, 1), // LT
+ vec2(-1, -1), // LB
+ vec2( 1, -1), // RB
+ vec2( 1, 1), // RT
+
+ vec2(-2, 2), // LT
+ vec2( 0, 2), // CT
+ vec2( 2, 2), // RT
+
+ vec2(0 ,-2), // LC
+ vec2(0 , 0), // CC
+ vec2(2, 0), // CR
+
+ vec2(-2, -2), // LB
+ vec2(0 , -2), // CB
+ vec2(2 , -2) // RB
+ };
+
+ float color_weights[13] = {
+ // 0.5f
+ 1.f/8.f,
+ 1.f/8.f,
+ 1.f/8.f,
+ 1.f/8.f,
+
+ // 0.125f
+ 1.f/32.f,
+ 1.f/16.f,
+ 1.f/32.f,
+
+ // 0.25f
+ 1.f/16.f,
+ 1.f/8.f,
+ 1.f/16.f,
+
+ // 0.125f
+ 1.f/32.f,
+ 1.f/16.f,
+ 1.f/32.f
+ };
+
+ vec3 sampled_color = vec3(0.0f);
+
+ for(uint i = 0; i < 13; i++)
+ {
+ vec2 color_fetch = UV_offset + color_fetches[i] * pixel_size;
+ vec3 color = texture(sampler2D(inBlurImage, inImageSampler), color_fetch).rgb;
+ color *= color_weights[i];
+ sampled_color += color;
+ }
+
+ imageStore(outBlurImage, pixel_coord, vec4(sampled_color, 1.f));
+}
\ No newline at end of file
diff --git a/projects/particle_simulation/shaders/bloom/lensFlares.comp b/projects/particle_simulation/shaders/bloom/lensFlares.comp
new file mode 100644
index 0000000000000000000000000000000000000000..ce27d8850b709f61332d467914ddc944dc63109f
--- /dev/null
+++ b/projects/particle_simulation/shaders/bloom/lensFlares.comp
@@ -0,0 +1,109 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(set=0, binding=0) uniform texture2D blurBuffer;
+layout(set=0, binding=1) uniform sampler linearSampler;
+layout(set=0, binding=2, r11f_g11f_b10f) uniform image2D lensBuffer;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+vec3 sampleColorChromaticAberration(vec2 _uv)
+{
+ vec2 toCenter = (vec2(0.5) - _uv);
+
+ vec3 colorScales = vec3(-1, 0, 1);
+ float aberrationScale = 0.1;
+ vec3 scaleFactors = colorScales * aberrationScale;
+
+ float r = texture(sampler2D(blurBuffer, linearSampler), _uv + toCenter * scaleFactors.r).r;
+ float g = texture(sampler2D(blurBuffer, linearSampler), _uv + toCenter * scaleFactors.g).g;
+ float b = texture(sampler2D(blurBuffer, linearSampler), _uv + toCenter * scaleFactors.b).b;
+ return vec3(r, g, b);
+}
+
+// _uv assumed to be flipped UV coordinates!
+vec3 ghost_vectors(vec2 _uv)
+{
+ vec2 ghost_vec = (vec2(0.5f) - _uv);
+
+ const uint c_ghost_count = 64;
+ const float c_ghost_spacing = length(ghost_vec) / c_ghost_count;
+
+ ghost_vec *= c_ghost_spacing;
+
+ vec3 ret_color = vec3(0.0f);
+
+ for (uint i = 0; i < c_ghost_count; ++i)
+ {
+ // sample scene color
+ vec2 s_uv = fract(_uv + ghost_vec * vec2(i));
+ vec3 s = sampleColorChromaticAberration(s_uv);
+
+ // tint/weight
+ float d = distance(s_uv, vec2(0.5));
+ float weight = 1.0f - smoothstep(0.0f, 0.75f, d);
+ s *= weight;
+
+ ret_color += s;
+ }
+
+ ret_color /= c_ghost_count;
+ return ret_color;
+}
+
+vec3 halo(vec2 _uv)
+{
+ const float c_aspect_ratio = float(imageSize(lensBuffer).x) / float(imageSize(lensBuffer).y);
+ const float c_radius = 0.6f;
+ const float c_halo_thickness = 0.1f;
+
+ vec2 halo_vec = vec2(0.5) - _uv;
+ //halo_vec.x /= c_aspect_ratio;
+ halo_vec = normalize(halo_vec);
+ //halo_vec.x *= c_aspect_ratio;
+
+
+ //vec2 w_uv = (_uv - vec2(0.5, 0.0)) * vec2(c_aspect_ratio, 1.0) + vec2(0.5, 0.0);
+ vec2 w_uv = _uv;
+ float d = distance(w_uv, vec2(0.5)); // distance to center
+
+ float distance_to_halo = abs(d - c_radius);
+
+ float halo_weight = 0.0f;
+ if(abs(d - c_radius) <= c_halo_thickness)
+ {
+ float distance_to_border = c_halo_thickness - distance_to_halo;
+ halo_weight = distance_to_border / c_halo_thickness;
+
+ //halo_weight = clamp((halo_weight / 0.4f), 0.0f, 1.0f);
+ halo_weight = pow(halo_weight, 2.0f);
+
+
+ //halo_weight = 1.0f;
+ }
+
+ return sampleColorChromaticAberration(_uv + halo_vec) * halo_weight;
+}
+
+
+
+void main()
+{
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(lensBuffer)))){
+ return;
+ }
+
+ ivec2 pixel_coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 pixel_size = vec2(1.0f) / imageSize(lensBuffer);
+ vec2 UV = pixel_coord.xy * pixel_size;
+
+ vec2 flipped_UV = vec2(1.0f) - UV;
+
+ vec3 color = vec3(0.0f);
+
+ color += ghost_vectors(flipped_UV);
+ color += halo(UV);
+ color *= 0.5f;
+
+ imageStore(lensBuffer, pixel_coord, vec4(color, 0.0f));
+}
\ No newline at end of file
diff --git a/projects/particle_simulation/shaders/bloom/upsample.comp b/projects/particle_simulation/shaders/bloom/upsample.comp
new file mode 100644
index 0000000000000000000000000000000000000000..0ddeedb5b5af9e476dc19012fed6430544006c0e
--- /dev/null
+++ b/projects/particle_simulation/shaders/bloom/upsample.comp
@@ -0,0 +1,45 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(set=0, binding=0) uniform texture2D inUpsampleImage;
+layout(set=0, binding=1) uniform sampler inImageSampler;
+layout(set=0, binding=2, r11f_g11f_b10f) uniform image2D outUpsampleImage;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+void main()
+{
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outUpsampleImage)))){
+ return;
+ }
+
+
+ ivec2 pixel_coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 pixel_size = vec2(1.0f) / imageSize(outUpsampleImage);
+ vec2 UV = pixel_coord.xy * pixel_size;
+
+ const float gauss_kernel[3] = {1.f, 2.f, 1.f};
+ const float gauss_weight = 16.f;
+
+ vec3 sampled_color = vec3(0.f);
+
+ for(int i = -1; i <= 1; i++)
+ {
+ for(int j = -1; j <= 1; j++)
+ {
+ vec2 sample_location = UV + vec2(j, i) * pixel_size;
+ vec3 color = texture(sampler2D(inUpsampleImage, inImageSampler), sample_location).rgb;
+ color *= gauss_kernel[j+1];
+ color *= gauss_kernel[i+1];
+ color /= gauss_weight;
+
+ sampled_color += color;
+ }
+ }
+
+ //vec3 prev_color = imageLoad(outUpsampleImage, pixel_coord).rgb;
+ //float bloomRimStrength = 0.75f; // adjust this to change strength of bloom
+ //sampled_color = mix(prev_color, sampled_color, bloomRimStrength);
+
+ imageStore(outUpsampleImage, pixel_coord, vec4(sampled_color, 1.f));
+}
\ No newline at end of file
diff --git a/projects/particle_simulation/shaders/particleShading.inc b/projects/particle_simulation/shaders/particleShading.inc
new file mode 100644
index 0000000000000000000000000000000000000000..b2d1832b9ccd6ba05a585b59bdfdedd4729e80f8
--- /dev/null
+++ b/projects/particle_simulation/shaders/particleShading.inc
@@ -0,0 +1,6 @@
+float circleFactor(vec2 triangleCoordinates){
+ // percentage of distance from center to circle edge
+ float p = clamp((0.4 - length(triangleCoordinates)) / 0.4, 0, 1);
+ // remapping for nice falloff
+ return sqrt(p);
+}
\ No newline at end of file
diff --git a/projects/particle_simulation/shaders/shader.vert b/projects/particle_simulation/shaders/shader.vert
new file mode 100644
index 0000000000000000000000000000000000000000..0a889b35dbb750dc932de57b611f22acaa1ac3f2
--- /dev/null
+++ b/projects/particle_simulation/shaders/shader.vert
@@ -0,0 +1,45 @@
+#version 460 core
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec3 particle;
+
+struct Particle
+{
+ vec3 position;
+ float lifeTime;
+ vec3 velocity;
+ float padding_2;
+ vec3 reset_velocity;
+ float padding_3;
+};
+
+layout(std430, binding = 2) coherent buffer buffer_inParticle
+{
+ Particle inParticle[];
+};
+
+layout( push_constant ) uniform constants{
+ mat4 view;
+ mat4 projection;
+};
+
+layout(location = 0) out vec2 passTriangleCoordinates;
+layout(location = 1) out vec3 passVelocity;
+layout(location = 2) out float passlifeTime;
+
+void main()
+{
+ int id = gl_InstanceIndex;
+ passVelocity = inParticle[id].velocity;
+ passlifeTime = inParticle[id].lifeTime;
+ // particle position in view space
+ vec4 positionView = view * vec4(inParticle[id].position, 1);
+ // by adding the triangle position in view space the mesh is always camera facing
+ positionView.xyz += particle;
+ // multiply with projection matrix for final position
+ gl_Position = projection * positionView;
+
+ // 0.01 corresponds to vertex position size in main
+ float normalizationDivider = 0.012;
+ passTriangleCoordinates = particle.xy / normalizationDivider;
+}
\ No newline at end of file
diff --git a/projects/particle_simulation/shaders/shader_gravity.comp b/projects/particle_simulation/shaders/shader_gravity.comp
new file mode 100644
index 0000000000000000000000000000000000000000..77954958c694a3c6c620818dd3b5d999e51b4a42
--- /dev/null
+++ b/projects/particle_simulation/shaders/shader_gravity.comp
@@ -0,0 +1,80 @@
+#version 450 core
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(local_size_x = 256) in;
+
+struct Particle
+{
+ vec3 position;
+ float lifeTime;
+ vec3 velocity;
+ float mass;
+ vec3 reset_velocity;
+ float _padding;
+};
+
+layout(std430, binding = 0) coherent buffer buffer_inParticle
+{
+ Particle inParticle[];
+};
+
+layout( push_constant ) uniform constants{
+ float deltaTime;
+ float rand;
+};
+
+const int n = 4;
+vec4 gravityPoint[n] = vec4[n](
+ vec4(-0.8, -0.5, 0.0, 3),
+ vec4(-0.4, 0.5, 0.8, 2),
+ vec4( 0.8, 0.8, -0.3, 4),
+ vec4( 0.5, -0.7, -0.5, 1)
+);
+
+const float G = 6.6743015e-11;
+const float sim_d_factor = 10e11;
+const float sim_g_factor = 10e30;
+const float sim_t_factor = 5;
+const float c = 299792458;
+
+void main() {
+ uint id = gl_GlobalInvocationID.x;
+ inParticle[id].lifeTime -= deltaTime;
+ vec3 pos = inParticle[id].position;
+ vec3 vel = inParticle[id].velocity;
+ float mass = inParticle[id].mass;
+
+ if(inParticle[id].lifeTime < 0.f)
+ {
+ inParticle[id].lifeTime = 5.f * rand;
+ inParticle[id].mass *= rand;
+
+ pos = vec3(0);
+ vel *= rand;
+ }
+
+ for(int i = 0; i < n; i++)
+ {
+ vec3 d = (gravityPoint[i].xyz - pos) * sim_d_factor;
+ float r = length(d);
+ float g = G * (gravityPoint[i].w * sim_g_factor) / (r * r);
+
+ if (r > 0) {
+ vec3 dvel = (deltaTime * sim_t_factor) * g * (d / r);
+
+ vel = (vel + dvel) / (1.0 + dot(vel, dvel) / (c*c));
+ }
+ }
+
+ pos += vel * (deltaTime * sim_t_factor);
+
+ vec3 a_pos = abs(pos);
+
+ if ((a_pos.x > 2.0) || (a_pos.y > 2.0) || (a_pos.z > 2.0))
+ {
+ inParticle[id].lifeTime *= 0.9;
+ }
+
+ inParticle[id].position = pos;
+ inParticle[id].velocity = vel;
+}
diff --git a/projects/particle_simulation/shaders/shader_space.comp b/projects/particle_simulation/shaders/shader_space.comp
new file mode 100644
index 0000000000000000000000000000000000000000..6e25fff8aec8ceab7c1ffdd9be65d9b8fa8f0974
--- /dev/null
+++ b/projects/particle_simulation/shaders/shader_space.comp
@@ -0,0 +1,73 @@
+#version 450 core
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(local_size_x = 256) in;
+
+struct Particle
+{
+ vec3 position;
+ float lifeTime;
+ vec3 velocity;
+ float padding_2;
+ vec3 reset_velocity;
+ float padding_3;
+};
+
+layout(std430, binding = 0) coherent buffer buffer_inParticle
+{
+ Particle inParticle[];
+};
+
+layout( push_constant ) uniform constants{
+ float deltaTime;
+ float rand;
+};
+
+vec3 attraction(vec3 pos, vec3 attractPos)
+{
+ vec3 delta = attractPos - pos;
+ const float damp = 0.5;
+ float dDampedDot = dot(delta, delta) + damp;
+ float invDist = 1.0f / sqrt(dDampedDot);
+ float invDistCubed = invDist*invDist*invDist;
+ return delta * invDistCubed * 0.0035;
+}
+
+vec3 repulsion(vec3 pos, vec3 attractPos)
+{
+ vec3 delta = attractPos - pos;
+ float targetDistance = sqrt(dot(delta, delta));
+ return delta * (1.0 / (targetDistance * targetDistance * targetDistance)) * -0.000035;
+}
+
+
+const int n = 4;
+vec3 gravity = vec3(0,-9.8,0);
+vec3 gravityPoint[n] = vec3[n](vec3(-0.3, .5, -0.6),vec3(-0.2, 0.6, -0.3),vec3(.4, -0.4, 0.6),vec3(-.4, -0.4, -0.6));
+//vec3 gravityPoint[n] = vec3[n](vec3(-0.5, 0.5, 0));
+void main() {
+ uint id = gl_GlobalInvocationID.x;
+ inParticle[id].lifeTime -= deltaTime;
+ vec3 pos = inParticle[id].position;
+ vec3 vel = inParticle[id].velocity;
+ if(inParticle[id].lifeTime < 0.f)
+ {
+ inParticle[id].lifeTime = 5.f;
+ pos = vec3(0);
+ }
+ // inParticle[id].position += deltaTime * -normalize(max(2 - distance(inParticle[id].position,respawnPos),0.0) * respawnPos - inParticle[id].position);
+
+ for(int i = 0; i < n; i++)
+ {
+ vel += deltaTime * deltaTime * normalize(max(2 - distance(pos,gravityPoint[i]),0.1) * gravityPoint[i] - pos);
+ }
+
+ if((pos.x <= -2.0) || (pos.x > 2.0) || (pos.y <= -2.0) || (pos.y > 2.0)|| (pos.z <= -2.0) || (pos.z > 2.0)){
+ vel = (-vel * 0.1);
+ }
+
+ pos += normalize(vel) * deltaTime;
+ inParticle[id].position = pos;
+ float rand1 = rand;
+ inParticle[id].velocity = vel;
+}
diff --git a/projects/particle_simulation/shaders/shader_space.frag b/projects/particle_simulation/shaders/shader_space.frag
new file mode 100644
index 0000000000000000000000000000000000000000..7f6d22065caa3c4b3ab2b1f697c9545a66d7bd54
--- /dev/null
+++ b/projects/particle_simulation/shaders/shader_space.frag
@@ -0,0 +1,46 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_GOOGLE_include_directive : enable
+
+#include "particleShading.inc"
+
+layout(location = 0) in vec2 passTriangleCoordinates;
+layout(location = 1) in vec3 passVelocity;
+layout(location = 2) in float passlifeTime;
+
+layout(location = 0) out vec3 outColor;
+
+layout(set=0, binding=0) uniform uColor {
+ vec4 color;
+} Color;
+
+layout(set=0,binding=1) uniform uPosition{
+ vec2 position;
+} Position;
+
+
+void main()
+{
+ vec2 mouse = vec2(Position.position.x, Position.position.y);
+
+ vec3 c0 = vec3(1, 1, 0.05);
+ vec3 c1 = vec3(1, passlifeTime * 0.5, 0.05);
+ vec3 c2 = vec3(passlifeTime * 0.5,passlifeTime * 0.5,0.05);
+ vec3 c3 = vec3(1, 0.05, 0.05);
+
+ if(passlifeTime < 1){
+ outColor = mix(c0, c1, passlifeTime );
+ }
+ else if(passlifeTime < 2){
+ outColor = mix(c1, c2, passlifeTime - 1);
+ }
+ else{
+ outColor = mix(c2, c3, clamp((passlifeTime - 2) * 0.5, 0, 1));
+ }
+
+ // make the triangle look like a circle
+ outColor *= circleFactor(passTriangleCoordinates);
+
+ // fade out particle shortly before it dies
+ outColor *= clamp(passlifeTime * 2, 0, 1);
+}
\ No newline at end of file
diff --git a/projects/particle_simulation/shaders/shader_water.comp b/projects/particle_simulation/shaders/shader_water.comp
new file mode 100644
index 0000000000000000000000000000000000000000..d1a0e761038b5fb367a33454c746871f1a6a4553
--- /dev/null
+++ b/projects/particle_simulation/shaders/shader_water.comp
@@ -0,0 +1,84 @@
+#version 450 core
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(local_size_x = 256) in;
+
+struct Particle
+{
+ vec3 position;
+ float lifeTime;
+ vec3 velocity;
+ float padding_2;
+ vec3 reset_velocity;
+ float padding_3;
+};
+
+layout(std430, binding = 0) coherent buffer buffer_inParticle
+{
+ Particle inParticle[];
+};
+
+layout( push_constant ) uniform constants{
+ float deltaTime;
+ float rand;
+};
+
+vec3 attraction(vec3 pos, vec3 attractPos)
+{
+ vec3 delta = attractPos - pos;
+ const float damp = 0.5;
+ float dDampedDot = dot(delta, delta) + damp;
+ float invDist = 1.0f / sqrt(dDampedDot);
+ float invDistCubed = invDist*invDist*invDist;
+ return delta * invDistCubed * 0.0035;
+}
+
+vec3 repulsion(vec3 pos, vec3 attractPos)
+{
+ vec3 delta = attractPos - pos;
+ float targetDistance = sqrt(dot(delta, delta));
+ return delta * (1.0 / (targetDistance * targetDistance * targetDistance)) * -0.000035;
+}
+
+
+const int n = 3;
+vec3 gravity = vec3(0,-9.8,0);
+vec3 gravityPoint[n] = vec3[n](vec3(-0.5, 0.5, 0),vec3(0.5, 0.5, 0),vec3(0, -0.5, 0));
+//vec3 gravityPoint[n] = vec3[n](vec3(-0.5, 0.5, 0));
+void main() {
+ uint id = gl_GlobalInvocationID.x;
+ inParticle[id].lifeTime -= deltaTime;
+ vec3 pos = inParticle[id].position;
+ vec3 vel = inParticle[id].velocity;
+ if(inParticle[id].lifeTime < 0.f)
+ {
+ inParticle[id].lifeTime = 7.f;
+ pos = vec3(0);
+ vel = inParticle[id].reset_velocity;
+ inParticle[id].velocity = inParticle[id].reset_velocity;
+ }
+ // inParticle[id].position += deltaTime * -normalize(max(2 - distance(inParticle[id].position,respawnPos),0.0) * respawnPos - inParticle[id].position);
+
+ for(int i = 0; i < n; i++)
+ {
+ vel += deltaTime * deltaTime * deltaTime * normalize(max(2 - distance(pos,gravityPoint[i]),0.1) * gravityPoint[i] - pos);
+ }
+
+ //vec3 delta = respawnPos - pos;
+ //float targetDistane = sqrt(dot(delta,delta));
+ //vel += repulsion(pos, respawnPos);
+
+ //if((pos.x <= -1.0) || (pos.x > 1.0) || (pos.y <= -1.0) || (pos.y > 1.0)|| (pos.z <= -1.0) || (pos.z > 1.0))
+ vel = (-vel * 0.01);
+
+ if((pos.y <= -1.0) || (pos.y > 1.0)){
+ vel = reflect(vel, vec3(0,1,0));
+ }
+
+ pos += normalize(vel) * deltaTime;
+ inParticle[id].position = pos;
+
+ float weight = 1.0;
+ float rand1 = rand;
+ inParticle[id].velocity = vel;
+}
diff --git a/projects/particle_simulation/shaders/shader_water.frag b/projects/particle_simulation/shaders/shader_water.frag
new file mode 100644
index 0000000000000000000000000000000000000000..b68f9572a91b05e836c3fead9ae9afd7ce16ba8e
--- /dev/null
+++ b/projects/particle_simulation/shaders/shader_water.frag
@@ -0,0 +1,46 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_GOOGLE_include_directive : enable
+
+#include "particleShading.inc"
+
+layout(location = 0) in vec2 passTriangleCoordinates;
+layout(location = 1) in vec3 passVelocity;
+layout(location = 2) in float passlifeTime;
+
+layout(location = 0) out vec3 outColor;
+
+layout(set=0, binding=0) uniform uColor {
+ vec4 color;
+} Color;
+
+layout(set=0,binding=1) uniform uPosition{
+ vec2 position;
+} Position;
+
+void main()
+{
+ float normlt = 1-normalize(passlifeTime);
+ vec2 mouse = vec2(Position.position.x, Position.position.y);
+
+ vec3 c0 = vec3(0.2,0.5,1);
+ vec3 c1 = vec3(0.3, 0.7,1);
+ vec3 c2 = vec3(0.5,0.9,1);
+ vec3 c3 = vec3(0.9,1,1);
+
+ if(passlifeTime < 1){
+ outColor = mix(c0, c1, passlifeTime );
+ }
+ else if(passlifeTime < 2){
+ outColor = mix(c1, c2, passlifeTime - 1);
+ }
+ else{
+ outColor = mix(c2, c3, clamp((passlifeTime - 2) * 0.5, 0, 1));
+ }
+
+ // make the triangle look like a circle
+ outColor *= circleFactor(passTriangleCoordinates);
+
+ // fade out particle shortly before it dies
+ outColor *= clamp(passlifeTime * 2, 0, 1);
+}
diff --git a/projects/particle_simulation/shaders/tonemapping.comp b/projects/particle_simulation/shaders/tonemapping.comp
new file mode 100644
index 0000000000000000000000000000000000000000..26f0232d66e3475afdd1266c0cc6288b47ed1c38
--- /dev/null
+++ b/projects/particle_simulation/shaders/tonemapping.comp
@@ -0,0 +1,19 @@
+#version 440
+
+layout(set=0, binding=0, rgba16f) uniform image2D inImage;
+layout(set=0, binding=1, rgba8) uniform image2D outImage;
+
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+void main(){
+
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(inImage)))){
+ return;
+ }
+ ivec2 uv = ivec2(gl_GlobalInvocationID.xy);
+ vec3 linearColor = imageLoad(inImage, uv).rgb;
+ vec3 tonemapped = linearColor / (dot(linearColor, vec3(0.21, 0.71, 0.08)) + 1); // reinhard tonemapping
+ vec3 gammaCorrected = pow(tonemapped, vec3(1.f / 2.2f));
+ imageStore(outImage, uv, vec4(gammaCorrected, 0.f));
+}
\ No newline at end of file
diff --git a/projects/particle_simulation/src/BloomAndFlares.cpp b/projects/particle_simulation/src/BloomAndFlares.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..23ace2bc35a2e421613718c62380f9161a408f70
--- /dev/null
+++ b/projects/particle_simulation/src/BloomAndFlares.cpp
@@ -0,0 +1,274 @@
+#include "BloomAndFlares.hpp"
+#include <vkcv/shader/GLSLCompiler.hpp>
+
+BloomAndFlares::BloomAndFlares(
+ vkcv::Core *p_Core,
+ vk::Format colorBufferFormat,
+ uint32_t width,
+ uint32_t height) :
+
+ p_Core(p_Core),
+ m_ColorBufferFormat(colorBufferFormat),
+ m_Width(width),
+ m_Height(height),
+ m_LinearSampler(p_Core->createSampler(vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::CLAMP_TO_EDGE)),
+ m_Blur(p_Core->createImage(colorBufferFormat, width, height, 1, true, true, false)),
+ m_LensFeatures(p_Core->createImage(colorBufferFormat, width, height, 1, false, true, false))
+{
+ vkcv::shader::GLSLCompiler compiler;
+
+ // DOWNSAMPLE
+ vkcv::ShaderProgram dsProg;
+ compiler.compile(vkcv::ShaderStage::COMPUTE,
+ "shaders/bloom/downsample.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
+ {
+ dsProg.addShader(shaderStage, path);
+ });
+ for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
+ {
+ m_DownsampleDescSets.push_back(
+ p_Core->createDescriptorSet(dsProg.getReflectedDescriptors()[0]));
+ }
+ m_DownsamplePipe = p_Core->createComputePipeline(
+ dsProg, { p_Core->getDescriptorSet(m_DownsampleDescSets[0]).layout });
+
+ // UPSAMPLE
+ vkcv::ShaderProgram usProg;
+ compiler.compile(vkcv::ShaderStage::COMPUTE,
+ "shaders/bloom/upsample.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
+ {
+ usProg.addShader(shaderStage, path);
+ });
+ for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
+ {
+ m_UpsampleDescSets.push_back(
+ p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
+ }
+ m_UpsamplePipe = p_Core->createComputePipeline(
+ usProg, { p_Core->getDescriptorSet(m_UpsampleDescSets[0]).layout });
+
+ // LENS FEATURES
+ vkcv::ShaderProgram lensProg;
+ compiler.compile(vkcv::ShaderStage::COMPUTE,
+ "shaders/bloom/lensFlares.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
+ {
+ lensProg.addShader(shaderStage, path);
+ });
+ m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors()[0]);
+ m_LensFlarePipe = p_Core->createComputePipeline(
+ lensProg, { p_Core->getDescriptorSet(m_LensFlareDescSet).layout });
+
+ // COMPOSITE
+ vkcv::ShaderProgram compProg;
+ compiler.compile(vkcv::ShaderStage::COMPUTE,
+ "shaders/bloom/composite.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
+ {
+ compProg.addShader(shaderStage, path);
+ });
+ m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors()[0]);
+ m_CompositePipe = p_Core->createComputePipeline(
+ compProg, { p_Core->getDescriptorSet(m_CompositeDescSet).layout });
+}
+
+void BloomAndFlares::execDownsamplePipe(const vkcv::CommandStreamHandle &cmdStream,
+ const vkcv::ImageHandle &colorAttachment)
+{
+ auto dispatchCountX = static_cast<float>(m_Width) / 8.0f;
+ auto dispatchCountY = static_cast<float>(m_Height) / 8.0f;
+ // blur dispatch
+ uint32_t initialDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(dispatchCountX)),
+ static_cast<uint32_t>(glm::ceil(dispatchCountY)),
+ 1
+ };
+
+ // downsample dispatch of original color attachment
+ p_Core->prepareImageForSampling(cmdStream, colorAttachment);
+ p_Core->prepareImageForStorage(cmdStream, m_Blur.getHandle());
+
+ vkcv::DescriptorWrites initialDownsampleWrites;
+ initialDownsampleWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, colorAttachment)};
+ initialDownsampleWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(1, m_LinearSampler)};
+ initialDownsampleWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(2, m_Blur.getHandle(), 0) };
+ p_Core->writeDescriptorSet(m_DownsampleDescSets[0], initialDownsampleWrites);
+
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_DownsamplePipe,
+ initialDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_DownsampleDescSets[0]).vulkanHandle)},
+ vkcv::PushConstantData(nullptr, 0));
+
+ // downsample dispatches of blur buffer's mip maps
+ float mipDispatchCountX = dispatchCountX;
+ float mipDispatchCountY = dispatchCountY;
+ for(uint32_t mipLevel = 1; mipLevel < std::min((uint32_t)m_DownsampleDescSets.size(), m_Blur.getMipCount()); mipLevel++)
+ {
+ // mip descriptor writes
+ vkcv::DescriptorWrites mipDescriptorWrites;
+ mipDescriptorWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, m_Blur.getHandle(), mipLevel - 1, true)};
+ mipDescriptorWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(1, m_LinearSampler)};
+ mipDescriptorWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(2, m_Blur.getHandle(), mipLevel) };
+ p_Core->writeDescriptorSet(m_DownsampleDescSets[mipLevel], mipDescriptorWrites);
+
+ // mip dispatch calculation
+ mipDispatchCountX /= 2.0f;
+ mipDispatchCountY /= 2.0f;
+
+ uint32_t mipDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(mipDispatchCountX)),
+ static_cast<uint32_t>(glm::ceil(mipDispatchCountY)),
+ 1
+ };
+
+ if(mipDispatchCount[0] == 0)
+ mipDispatchCount[0] = 1;
+ if(mipDispatchCount[1] == 0)
+ mipDispatchCount[1] = 1;
+
+ // mip blur dispatch
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_DownsamplePipe,
+ mipDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_DownsampleDescSets[mipLevel]).vulkanHandle)},
+ vkcv::PushConstantData(nullptr, 0));
+
+ // image barrier between mips
+ p_Core->recordImageMemoryBarrier(cmdStream, m_Blur.getHandle());
+ }
+}
+
+void BloomAndFlares::execUpsamplePipe(const vkcv::CommandStreamHandle &cmdStream)
+{
+ // upsample dispatch
+ p_Core->prepareImageForStorage(cmdStream, m_Blur.getHandle());
+
+ const uint32_t upsampleMipLevels = std::min(
+ static_cast<uint32_t>(m_UpsampleDescSets.size() - 1),
+ static_cast<uint32_t>(3)
+ );
+
+ // upsample dispatch for each mip map
+ for(uint32_t mipLevel = upsampleMipLevels; mipLevel > 0; mipLevel--)
+ {
+ // mip descriptor writes
+ vkcv::DescriptorWrites mipUpsampleWrites;
+ mipUpsampleWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, m_Blur.getHandle(), mipLevel, true)};
+ mipUpsampleWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(1, m_LinearSampler)};
+ mipUpsampleWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(2, m_Blur.getHandle(), mipLevel - 1) };
+ p_Core->writeDescriptorSet(m_UpsampleDescSets[mipLevel], mipUpsampleWrites);
+
+ auto mipDivisor = glm::pow(2.0f, static_cast<float>(mipLevel) - 1.0f);
+
+ auto upsampleDispatchX = static_cast<float>(m_Width) / mipDivisor;
+ auto upsampleDispatchY = static_cast<float>(m_Height) / mipDivisor;
+ upsampleDispatchX /= 8.0f;
+ upsampleDispatchY /= 8.0f;
+
+ const uint32_t upsampleDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(upsampleDispatchX)),
+ static_cast<uint32_t>(glm::ceil(upsampleDispatchY)),
+ 1
+ };
+
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_UpsamplePipe,
+ upsampleDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_UpsampleDescSets[mipLevel]).vulkanHandle)},
+ vkcv::PushConstantData(nullptr, 0)
+ );
+ // image barrier between mips
+ p_Core->recordImageMemoryBarrier(cmdStream, m_Blur.getHandle());
+ }
+}
+
+void BloomAndFlares::execLensFeaturePipe(const vkcv::CommandStreamHandle &cmdStream)
+{
+ // lens feature generation descriptor writes
+ p_Core->prepareImageForSampling(cmdStream, m_Blur.getHandle());
+ p_Core->prepareImageForStorage(cmdStream, m_LensFeatures.getHandle());
+
+ vkcv::DescriptorWrites lensFeatureWrites;
+ lensFeatureWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, m_Blur.getHandle(), 0)};
+ lensFeatureWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(1, m_LinearSampler)};
+ lensFeatureWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(2, m_LensFeatures.getHandle(), 0)};
+ p_Core->writeDescriptorSet(m_LensFlareDescSet, lensFeatureWrites);
+
+ auto dispatchCountX = static_cast<float>(m_Width) / 8.0f;
+ auto dispatchCountY = static_cast<float>(m_Height) / 8.0f;
+ // lens feature generation dispatch
+ uint32_t lensFeatureDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(dispatchCountX)),
+ static_cast<uint32_t>(glm::ceil(dispatchCountY)),
+ 1
+ };
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_LensFlarePipe,
+ lensFeatureDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_LensFlareDescSet).vulkanHandle)},
+ vkcv::PushConstantData(nullptr, 0));
+}
+
+void BloomAndFlares::execCompositePipe(const vkcv::CommandStreamHandle &cmdStream,
+ const vkcv::ImageHandle &colorAttachment)
+{
+ p_Core->prepareImageForSampling(cmdStream, m_Blur.getHandle());
+ p_Core->prepareImageForSampling(cmdStream, m_LensFeatures.getHandle());
+ p_Core->prepareImageForStorage(cmdStream, colorAttachment);
+
+ // bloom composite descriptor write
+ vkcv::DescriptorWrites compositeWrites;
+ compositeWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, m_Blur.getHandle()),
+ vkcv::SampledImageDescriptorWrite(1, m_LensFeatures.getHandle())};
+ compositeWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(2, m_LinearSampler)};
+ compositeWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(3, colorAttachment)};
+ p_Core->writeDescriptorSet(m_CompositeDescSet, compositeWrites);
+
+ float dispatchCountX = static_cast<float>(m_Width) / 8.0f;
+ float dispatchCountY = static_cast<float>(m_Height) / 8.0f;
+
+ uint32_t compositeDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(dispatchCountX)),
+ static_cast<uint32_t>(glm::ceil(dispatchCountY)),
+ 1
+ };
+
+ // bloom composite dispatch
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_CompositePipe,
+ compositeDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_CompositeDescSet).vulkanHandle)},
+ vkcv::PushConstantData(nullptr, 0));
+}
+
+void BloomAndFlares::execWholePipeline(const vkcv::CommandStreamHandle &cmdStream,
+ const vkcv::ImageHandle &colorAttachment)
+{
+ execDownsamplePipe(cmdStream, colorAttachment);
+ execUpsamplePipe(cmdStream);
+ execLensFeaturePipe(cmdStream);
+ execCompositePipe(cmdStream, colorAttachment);
+}
+
+void BloomAndFlares::updateImageDimensions(uint32_t width, uint32_t height)
+{
+ m_Width = width;
+ m_Height = height;
+
+ p_Core->getContext().getDevice().waitIdle();
+ m_Blur = p_Core->createImage(m_ColorBufferFormat, m_Width, m_Height, 1, true, true, false);
+ m_LensFeatures = p_Core->createImage(m_ColorBufferFormat, m_Width, m_Height, 1, false, true, false);
+}
+
+
diff --git a/projects/particle_simulation/src/BloomAndFlares.hpp b/projects/particle_simulation/src/BloomAndFlares.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..756b1ca154ea5232df04eb09a88bb743c5bd28aa
--- /dev/null
+++ b/projects/particle_simulation/src/BloomAndFlares.hpp
@@ -0,0 +1,47 @@
+#pragma once
+#include <vkcv/Core.hpp>
+#include <glm/glm.hpp>
+
+class BloomAndFlares{
+public:
+ BloomAndFlares(vkcv::Core *p_Core,
+ vk::Format colorBufferFormat,
+ uint32_t width,
+ uint32_t height);
+
+ void execWholePipeline(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle &colorAttachment);
+
+ void updateImageDimensions(uint32_t width, uint32_t height);
+
+private:
+ vkcv::Core *p_Core;
+
+ vk::Format m_ColorBufferFormat;
+ uint32_t m_Width;
+ uint32_t m_Height;
+
+ vkcv::SamplerHandle m_LinearSampler;
+ vkcv::Image m_Blur;
+ vkcv::Image m_LensFeatures;
+
+
+ vkcv::PipelineHandle m_DownsamplePipe;
+ std::vector<vkcv::DescriptorSetHandle> m_DownsampleDescSets; // per mip desc set
+
+ vkcv::PipelineHandle m_UpsamplePipe;
+ std::vector<vkcv::DescriptorSetHandle> m_UpsampleDescSets; // per mip desc set
+
+ vkcv::PipelineHandle m_LensFlarePipe;
+ vkcv::DescriptorSetHandle m_LensFlareDescSet;
+
+ vkcv::PipelineHandle m_CompositePipe;
+ vkcv::DescriptorSetHandle m_CompositeDescSet;
+
+ void execDownsamplePipe(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle &colorAttachment);
+ void execUpsamplePipe(const vkcv::CommandStreamHandle &cmdStream);
+ void execLensFeaturePipe(const vkcv::CommandStreamHandle &cmdStream);
+ void execCompositePipe(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle &colorAttachment);
+};
+
+
+
diff --git a/projects/particle_simulation/src/Particle.cpp b/projects/particle_simulation/src/Particle.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..387728eb366430e4373282da785bbff47de17e7a
--- /dev/null
+++ b/projects/particle_simulation/src/Particle.cpp
@@ -0,0 +1,41 @@
+
+#include "Particle.hpp"
+
+Particle::Particle(glm::vec3 position, glm::vec3 velocity, float lifeTime)
+: m_position(position),
+m_velocity(velocity),
+m_lifeTime(lifeTime),
+m_reset_velocity(velocity)
+{}
+
+const glm::vec3& Particle::getPosition()const{
+ return m_position;
+}
+
+const bool Particle::isAlive()const{
+ return m_lifeTime > 0.f;
+}
+
+void Particle::setPosition( const glm::vec3 pos ){
+ m_position = pos;
+}
+
+const glm::vec3& Particle::getVelocity()const{
+ return m_velocity;
+}
+
+void Particle::setVelocity( const glm::vec3 vel ){
+ m_velocity = vel;
+}
+
+void Particle::update( const float delta ){
+ m_position += m_velocity * delta;
+}
+
+void Particle::setLifeTime( const float lifeTime ){
+ m_lifeTime = lifeTime;
+}
+
+const float& Particle::getLifeTime()const{
+ return m_lifeTime;
+}
\ No newline at end of file
diff --git a/projects/particle_simulation/src/Particle.hpp b/projects/particle_simulation/src/Particle.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f374218fd8a08f1e1bf367bdc899a71c55ea1b78
--- /dev/null
+++ b/projects/particle_simulation/src/Particle.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <glm/glm.hpp>
+
+class Particle {
+
+public:
+ Particle(glm::vec3 position, glm::vec3 velocity, float lifeTime = 1.f);
+
+ const glm::vec3& getPosition()const;
+
+ void setPosition( const glm::vec3 pos );
+
+ const glm::vec3& getVelocity()const;
+
+ void setVelocity( const glm::vec3 vel );
+
+ void update( const float delta );
+
+ const bool isAlive()const;
+
+ void setLifeTime( const float lifeTime );
+
+ const float& getLifeTime()const;
+
+private:
+ // all properties of the Particle
+ glm::vec3 m_position;
+ float m_lifeTime;
+ glm::vec3 m_velocity;
+ float mass = 1.f;
+ glm::vec3 m_reset_velocity;
+ float padding_3 = 0.f;
+};
diff --git a/projects/particle_simulation/src/ParticleSystem.cpp b/projects/particle_simulation/src/ParticleSystem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b3162d6bea685640d3949577271affc8b2080407
--- /dev/null
+++ b/projects/particle_simulation/src/ParticleSystem.cpp
@@ -0,0 +1,60 @@
+#include "ParticleSystem.hpp"
+
+ParticleSystem::ParticleSystem(uint32_t particleCount ,glm::vec3 minVelocity , glm::vec3 maxVelocity , glm::vec2 lifeTime )
+{
+ m_rdmVel.resize(3);
+ m_rdmVel[0] = std::uniform_real_distribution<float>(minVelocity.x, maxVelocity.x);
+ m_rdmVel[1] = std::uniform_real_distribution<float>(minVelocity.y, maxVelocity.y);
+ m_rdmVel[2] = std::uniform_real_distribution<float>(minVelocity.z, maxVelocity.z);
+ m_rdmLifeTime = std::uniform_real_distribution<float>(lifeTime.x, lifeTime.y);
+
+ for(uint32_t i = 0; i < particleCount ;i++ ){
+ addParticle(Particle(m_respawnPos, getRandomVelocity(), getRandomLifeTime()));
+ }
+}
+
+const std::vector<Particle>& ParticleSystem::getParticles() const{
+ return m_particles;
+}
+
+void ParticleSystem::addParticle( const Particle particle ){
+ m_particles.push_back(particle);
+}
+void ParticleSystem::addParticles( const std::vector<Particle> particles ){
+ m_particles.insert(m_particles.end(), particles.begin(), particles.end());
+}
+
+void ParticleSystem::updateParticles( const float deltaTime ){
+ for(Particle& particle :m_particles){
+ bool alive = particle.isAlive();
+ particle.setPosition( particle.getPosition() * static_cast<float>(alive) + static_cast<float>(!alive) * m_respawnPos );
+ particle.setVelocity( particle.getVelocity() * static_cast<float>(alive) + static_cast<float>(!alive) * getRandomVelocity());
+ particle.setLifeTime( (particle.getLifeTime() * alive + !alive * getRandomLifeTime() ) - deltaTime );
+ particle.update(deltaTime);
+ }
+}
+
+glm::vec3 ParticleSystem::getRandomVelocity(){
+ return glm::vec3(m_rdmVel[0](m_rdmEngine), m_rdmVel[1](m_rdmEngine),m_rdmVel[2](m_rdmEngine));
+}
+
+float ParticleSystem::getRandomLifeTime(){
+ return m_rdmLifeTime(m_rdmEngine);
+}
+
+void ParticleSystem::setRespawnPos( const glm::vec3 respawnPos){
+ m_respawnPos = respawnPos;
+}
+void ParticleSystem::setRdmLifeTime( const glm::vec2 lifeTime ){
+ m_rdmLifeTime = std::uniform_real_distribution<float> (lifeTime.x,lifeTime.y);
+}
+
+void ParticleSystem::setRdmVelocity( glm::vec3 minVelocity, glm::vec3 maxVelocity ){
+ m_rdmVel[0] = std::uniform_real_distribution<float> (minVelocity.x,maxVelocity.x);
+ m_rdmVel[1] = std::uniform_real_distribution<float> (minVelocity.y,maxVelocity.y);
+ m_rdmVel[2] = std::uniform_real_distribution<float> (minVelocity.z,maxVelocity.z);
+}
+
+const glm::vec3 ParticleSystem::getRespawnPos() const{
+ return m_respawnPos;
+}
diff --git a/projects/particle_simulation/src/ParticleSystem.hpp b/projects/particle_simulation/src/ParticleSystem.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe5c99f9b407b9dbdfd414e265e7cd91bbe790b9
--- /dev/null
+++ b/projects/particle_simulation/src/ParticleSystem.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <vector>
+#include "Particle.hpp"
+#include <random>
+#include "vkcv/Buffer.hpp"
+
+class ParticleSystem {
+
+public:
+ ParticleSystem(uint32_t particleCount , glm::vec3 minVelocity = glm::vec3(0.f,0.f,0.f), glm::vec3 maxVelocity = glm::vec3(1.f,1.f,0.f), glm::vec2 lifeTime = glm::vec2(2.f,3.f));
+ const std::vector<Particle> &getParticles() const;
+ void updateParticles( const float deltaTime );
+ void setRespawnPos( const glm::vec3 respawnPos );
+ void setRdmLifeTime( const glm::vec2 lifeTime );
+ void setRdmVelocity( glm::vec3 minVelocity, glm::vec3 maxVelocity );
+ const glm::vec3 getRespawnPos() const;
+
+private:
+
+ void addParticle( const Particle particle );
+ void addParticles( const std::vector<Particle> particles );
+ glm::vec3 getRandomVelocity();
+ float getRandomLifeTime();
+
+ std::vector<Particle> m_particles;
+ glm::vec3 m_respawnPos = glm::vec3(0.f);
+
+ std::vector<std::uniform_real_distribution<float>> m_rdmVel;
+ std::uniform_real_distribution<float> m_rdmLifeTime;
+ std::default_random_engine m_rdmEngine;
+};
\ No newline at end of file
diff --git a/projects/particle_simulation/src/main.cpp b/projects/particle_simulation/src/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a22044f0d2588a43a5e7a0f6cba25d9c7460be9f
--- /dev/null
+++ b/projects/particle_simulation/src/main.cpp
@@ -0,0 +1,320 @@
+#include <iostream>
+#include <vkcv/Core.hpp>
+#include <GLFW/glfw3.h>
+#include <vkcv/camera/CameraManager.hpp>
+#include <chrono>
+#include "ParticleSystem.hpp"
+#include <random>
+#include <glm/gtc/matrix_access.hpp>
+#include <time.h>
+#include <vkcv/shader/GLSLCompiler.hpp>
+#include "BloomAndFlares.hpp"
+
+int main(int argc, const char **argv) {
+ const char *applicationName = "Particlesystem";
+
+ uint32_t windowWidth = 800;
+ uint32_t windowHeight = 600;
+ vkcv::Window window = vkcv::Window::create(
+ applicationName,
+ windowWidth,
+ windowHeight,
+ true
+ );
+
+ vkcv::camera::CameraManager cameraManager(window);
+
+ vkcv::Core core = vkcv::Core::create(
+ window,
+ applicationName,
+ VK_MAKE_VERSION(0, 0, 1),
+ {vk::QueueFlagBits::eTransfer, vk::QueueFlagBits::eGraphics, vk::QueueFlagBits::eCompute},
+ {},
+ {"VK_KHR_swapchain"}
+ );
+
+ auto particleIndexBuffer = core.createBuffer<uint16_t>(vkcv::BufferType::INDEX, 3,
+ vkcv::BufferMemoryType::DEVICE_LOCAL);
+ uint16_t indices[3] = {0, 1, 2};
+ particleIndexBuffer.fill(&indices[0], sizeof(indices));
+
+ vk::Format colorFormat = vk::Format::eR16G16B16A16Sfloat;
+ // an example attachment for passes that output to the window
+ const vkcv::AttachmentDescription present_color_attachment(
+ vkcv::AttachmentOperation::STORE,
+ vkcv::AttachmentOperation::CLEAR,
+ colorFormat);
+
+
+ vkcv::PassConfig particlePassDefinition({present_color_attachment});
+ vkcv::PassHandle particlePass = core.createPass(particlePassDefinition);
+
+ vkcv::PassConfig computePassDefinition({});
+ vkcv::PassHandle computePass = core.createPass(computePassDefinition);
+
+ if (!particlePass || !computePass)
+ {
+ std::cout << "Error. Could not create renderpass. Exiting." << std::endl;
+ return EXIT_FAILURE;
+ }
+
+ // use space or use water
+ bool useSpace = true;
+
+ vkcv::shader::GLSLCompiler compiler;
+ vkcv::ShaderProgram computeShaderProgram{};
+ compiler.compile(vkcv::ShaderStage::COMPUTE, useSpace ? "shaders/shader_space.comp" : "shaders/shader_water.comp", [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ computeShaderProgram.addShader(shaderStage, path);
+ });
+
+ vkcv::DescriptorSetHandle computeDescriptorSet = core.createDescriptorSet(computeShaderProgram.getReflectedDescriptors()[0]);
+
+ const std::vector<vkcv::VertexAttachment> computeVertexAttachments = computeShaderProgram.getVertexAttachments();
+
+ std::vector<vkcv::VertexBinding> computeBindings;
+ for (size_t i = 0; i < computeVertexAttachments.size(); i++) {
+ computeBindings.push_back(vkcv::VertexBinding(i, { computeVertexAttachments[i] }));
+ }
+ const vkcv::VertexLayout computeLayout(computeBindings);
+
+ vkcv::ShaderProgram particleShaderProgram{};
+ compiler.compile(vkcv::ShaderStage::VERTEX, "shaders/shader.vert", [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ particleShaderProgram.addShader(shaderStage, path);
+ });
+ compiler.compile(vkcv::ShaderStage::FRAGMENT, useSpace ? "shaders/shader_space.frag" : "shaders/shader_water.frag", [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ particleShaderProgram.addShader(shaderStage, path);
+ });
+
+ vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(
+ particleShaderProgram.getReflectedDescriptors()[0]);
+
+ vkcv::Buffer<glm::vec3> vertexBuffer = core.createBuffer<glm::vec3>(
+ vkcv::BufferType::VERTEX,
+ 3
+ );
+ const std::vector<vkcv::VertexAttachment> vertexAttachments = particleShaderProgram.getVertexAttachments();
+
+ const std::vector<vkcv::VertexBufferBinding> vertexBufferBindings = {
+ vkcv::VertexBufferBinding(0, vertexBuffer.getVulkanHandle())};
+
+ std::vector<vkcv::VertexBinding> bindings;
+ for (size_t i = 0; i < vertexAttachments.size(); i++) {
+ bindings.push_back(vkcv::VertexBinding(i, {vertexAttachments[i]}));
+ }
+
+ const vkcv::VertexLayout particleLayout(bindings);
+
+ vkcv::PipelineConfig particlePipelineDefinition{
+ particleShaderProgram,
+ UINT32_MAX,
+ UINT32_MAX,
+ particlePass,
+ {particleLayout},
+ {core.getDescriptorSet(descriptorSet).layout},
+ true};
+ particlePipelineDefinition.m_blendMode = vkcv::BlendMode::Additive;
+
+ const std::vector<glm::vec3> vertices = {glm::vec3(-0.012, 0.012, 0),
+ glm::vec3(0.012, 0.012, 0),
+ glm::vec3(0, -0.012, 0)};
+
+ vertexBuffer.fill(vertices);
+
+ vkcv::PipelineHandle particlePipeline = core.createGraphicsPipeline(particlePipelineDefinition);
+
+ vkcv::PipelineHandle computePipeline = core.createComputePipeline(computeShaderProgram, {core.getDescriptorSet(computeDescriptorSet).layout} );
+
+ vkcv::Buffer<glm::vec4> color = core.createBuffer<glm::vec4>(
+ vkcv::BufferType::UNIFORM,
+ 1
+ );
+
+ vkcv::Buffer<glm::vec2> position = core.createBuffer<glm::vec2>(
+ vkcv::BufferType::UNIFORM,
+ 1
+ );
+
+ glm::vec3 minVelocity = glm::vec3(-0.1f,-0.1f,-0.1f);
+ glm::vec3 maxVelocity = glm::vec3(0.1f,0.1f,0.1f);
+ glm::vec2 lifeTime = glm::vec2(-1.f,8.f);
+ ParticleSystem particleSystem = ParticleSystem( 100000 , minVelocity, maxVelocity, lifeTime);
+
+ vkcv::Buffer<Particle> particleBuffer = core.createBuffer<Particle>(
+ vkcv::BufferType::STORAGE,
+ particleSystem.getParticles().size()
+ );
+
+ particleBuffer.fill(particleSystem.getParticles());
+
+ vkcv::DescriptorWrites setWrites;
+ setWrites.uniformBufferWrites = {vkcv::UniformBufferDescriptorWrite(0,color.getHandle()),
+ vkcv::UniformBufferDescriptorWrite(1,position.getHandle())};
+ setWrites.storageBufferWrites = { vkcv::StorageBufferDescriptorWrite(2,particleBuffer.getHandle())};
+ core.writeDescriptorSet(descriptorSet, setWrites);
+
+ vkcv::DescriptorWrites computeWrites;
+ computeWrites.storageBufferWrites = { vkcv::StorageBufferDescriptorWrite(0,particleBuffer.getHandle())};
+ core.writeDescriptorSet(computeDescriptorSet, computeWrites);
+
+ if (!particlePipeline || !computePipeline)
+ {
+ std::cout << "Error. Could not create graphics pipeline. Exiting." << std::endl;
+ return EXIT_FAILURE;
+ }
+
+ const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
+
+ const vkcv::Mesh renderMesh({vertexBufferBindings}, particleIndexBuffer.getVulkanHandle(),
+ particleIndexBuffer.getCount());
+ vkcv::DescriptorSetUsage descriptorUsage(0, core.getDescriptorSet(descriptorSet).vulkanHandle);
+ //vkcv::DrawcallInfo drawcalls(renderMesh, {vkcv::DescriptorSetUsage(0, core.getDescriptorSet(descriptorSet).vulkanHandle)});
+
+ glm::vec2 pos = glm::vec2(0.f);
+ glm::vec3 spawnPosition = glm::vec3(0.f);
+ glm::vec4 tempPosition = glm::vec4(0.f);
+
+ window.e_mouseMove.add([&](double offsetX, double offsetY) {
+ pos = glm::vec2(static_cast<float>(offsetX), static_cast<float>(offsetY));
+// std::cout << offsetX << " , " << offsetY << std::endl;
+ // borders are assumed to be 0.5
+ //pos = glm::vec2((pos.x -0.5f * static_cast<float>(window.getWidth()))/static_cast<float>(window.getWidth()), (pos.y -0.5f * static_cast<float>(window.getHeight()))/static_cast<float>(window.getHeight()));
+ //borders are assumed to be 1
+ pos.x = (-2 * pos.x + static_cast<float>(window.getWidth())) / static_cast<float>(window.getWidth());
+ pos.y = (-2 * pos.y + static_cast<float>(window.getHeight())) / static_cast<float>(window.getHeight());
+ glm::vec4 row1 = glm::row(cameraManager.getCamera(0).getView(), 0);
+ glm::vec4 row2 = glm::row(cameraManager.getCamera(0).getView(), 1);
+ glm::vec4 row3 = glm::row(cameraManager.getCamera(0).getView(), 2);
+ glm::vec4 camera_pos = glm::column(cameraManager.getCamera(0).getView(), 3);
+// std::cout << "row1: " << row1.x << ", " << row1.y << ", " << row1.z << std::endl;
+// std::cout << "row2: " << row2.x << ", " << row2.y << ", " << row2.z << std::endl;
+// std::cout << "row3: " << row3.x << ", " << row3.y << ", " << row3.z << std::endl;
+// std::cout << "camerapos: " << camera_pos.x << ", " << camera_pos.y << ", " << camera_pos.z << std::endl;
+// std::cout << "camerapos: " << camera_pos.x << ", " << camera_pos.y << ", " << camera_pos.z << std::endl;
+ //glm::vec4 view_axis = glm::row(cameraManager.getCamera().getView(), 2);
+ // std::cout << "view_axis: " << view_axis.x << ", " << view_axis.y << ", " << view_axis.z << std::endl;
+ //std::cout << "Front: " << cameraManager.getCamera().getFront().x << ", " << cameraManager.getCamera().getFront().z << ", " << cameraManager.getCamera().getFront().z << std::endl;
+ glm::mat4 viewmat = cameraManager.getCamera(0).getView();
+ spawnPosition = glm::vec3(pos.x, pos.y, 0.f);
+ tempPosition = glm::vec4(spawnPosition, 1.0f);
+ spawnPosition = glm::vec3(tempPosition.x, tempPosition.y, tempPosition.z);
+ particleSystem.setRespawnPos(glm::vec3(-spawnPosition.x, spawnPosition.y, spawnPosition.z));
+// std::cout << "respawn pos: " << spawnPosition.x << ", " << spawnPosition.y << ", " << spawnPosition.z << std::endl;
+ });
+
+ std::vector<glm::mat4> modelMatrices;
+ std::vector<vkcv::DrawcallInfo> drawcalls;
+ drawcalls.push_back(vkcv::DrawcallInfo(renderMesh, {descriptorUsage}, particleSystem.getParticles().size()));
+
+ auto start = std::chrono::system_clock::now();
+
+ glm::vec4 colorData = glm::vec4(1.0f, 1.0f, 0.0f, 1.0f);
+ uint32_t camIndex0 = cameraManager.addCamera(vkcv::camera::ControllerType::PILOT);
+ uint32_t camIndex1 = cameraManager.addCamera(vkcv::camera::ControllerType::TRACKBALL);
+
+ cameraManager.getCamera(camIndex0).setNearFar(0.1, 30);
+ cameraManager.getCamera(camIndex1).setNearFar(0.1, 30);
+
+ cameraManager.setActiveCamera(1);
+
+ cameraManager.getCamera(camIndex0).setPosition(glm::vec3(0, 0, -2));
+ cameraManager.getCamera(camIndex1).setPosition(glm::vec3(0.0f, 0.0f, -2.0f));
+ cameraManager.getCamera(camIndex1).setCenter(glm::vec3(0.0f, 0.0f, 0.0f));
+
+ vkcv::ImageHandle colorBuffer = core.createImage(colorFormat, windowWidth, windowHeight, 1, false, true, true).getHandle();
+ BloomAndFlares bloomAndFlares(&core, colorFormat, windowWidth, windowHeight);
+ window.e_resize.add([&](int width, int height) {
+ windowWidth = width;
+ windowHeight = height;
+ colorBuffer = core.createImage(colorFormat, windowWidth, windowHeight, 1, false, true, true).getHandle();
+ bloomAndFlares.updateImageDimensions(width, height);
+ });
+
+ vkcv::ShaderProgram tonemappingShader;
+ compiler.compile(vkcv::ShaderStage::COMPUTE, "shaders/tonemapping.comp", [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ tonemappingShader.addShader(shaderStage, path);
+ });
+
+ vkcv::DescriptorSetHandle tonemappingDescriptor = core.createDescriptorSet(tonemappingShader.getReflectedDescriptors()[0]);
+ vkcv::PipelineHandle tonemappingPipe = core.createComputePipeline(
+ tonemappingShader,
+ { core.getDescriptorSet(tonemappingDescriptor).layout });
+
+ std::uniform_real_distribution<float> rdm = std::uniform_real_distribution<float>(0.95f, 1.05f);
+ std::default_random_engine rdmEngine;
+ while (window.isWindowOpen()) {
+ window.pollEvents();
+
+ uint32_t swapchainWidth, swapchainHeight;
+ if (!core.beginFrame(swapchainWidth, swapchainHeight)) {
+ continue;
+ }
+
+ color.fill(&colorData);
+ position.fill(&pos);
+
+ auto end = std::chrono::system_clock::now();
+ float deltatime = 0.000001 * static_cast<float>( std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() );
+ start = end;
+// particleSystem.updateParticles(deltatime);
+
+ cameraManager.update(deltatime);
+
+ // split view and projection to allow for easy billboarding in shader
+ glm::mat4 renderingMatrices[2];
+ renderingMatrices[0] = cameraManager.getActiveCamera().getView();
+ renderingMatrices[1] = cameraManager.getActiveCamera().getProjection();
+
+ auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
+ float random = rdm(rdmEngine);
+ glm::vec2 pushData = glm::vec2(deltatime, random);
+
+ vkcv::PushConstantData pushConstantDataCompute( &pushData, sizeof(glm::vec2));
+ uint32_t computeDispatchCount[3] = {static_cast<uint32_t> (std::ceil(particleSystem.getParticles().size()/256.f)),1,1};
+ core.recordComputeDispatchToCmdStream(cmdStream,
+ computePipeline,
+ computeDispatchCount,
+ {vkcv::DescriptorSetUsage(0,core.getDescriptorSet(computeDescriptorSet).vulkanHandle)},
+ pushConstantDataCompute);
+
+ core.recordBufferMemoryBarrier(cmdStream, particleBuffer.getHandle());
+
+ vkcv::PushConstantData pushConstantDataDraw((void *) &renderingMatrices[0], 2 * sizeof(glm::mat4));
+ core.recordDrawcallsToCmdStream(
+ cmdStream,
+ particlePass,
+ particlePipeline,
+ pushConstantDataDraw,
+ {drawcalls},
+ { colorBuffer });
+
+ bloomAndFlares.execWholePipeline(cmdStream, colorBuffer);
+
+ core.prepareImageForStorage(cmdStream, colorBuffer);
+ core.prepareImageForStorage(cmdStream, swapchainInput);
+
+ vkcv::DescriptorWrites tonemappingDescriptorWrites;
+ tonemappingDescriptorWrites.storageImageWrites = {
+ vkcv::StorageImageDescriptorWrite(0, colorBuffer),
+ vkcv::StorageImageDescriptorWrite(1, swapchainInput)
+ };
+ core.writeDescriptorSet(tonemappingDescriptor, tonemappingDescriptorWrites);
+
+ uint32_t tonemappingDispatchCount[3];
+ tonemappingDispatchCount[0] = std::ceil(windowWidth / 8.f);
+ tonemappingDispatchCount[1] = std::ceil(windowHeight / 8.f);
+ tonemappingDispatchCount[2] = 1;
+
+ core.recordComputeDispatchToCmdStream(
+ cmdStream,
+ tonemappingPipe,
+ tonemappingDispatchCount,
+ {vkcv::DescriptorSetUsage(0, core.getDescriptorSet(tonemappingDescriptor).vulkanHandle) },
+ vkcv::PushConstantData(nullptr, 0));
+
+ core.prepareSwapchainImageForPresent(cmdStream);
+ core.submitCommandStream(cmdStream);
+ core.endFrame();
+ }
+
+ return 0;
+}
diff --git a/projects/voxelization/CMakeLists.txt b/projects/voxelization/CMakeLists.txt
index bc87996096226af4e3f3d05c3e10bb287c61cc8d..c962409f2e14994f0c38b923de7b9b1a4d198cab 100644
--- a/projects/voxelization/CMakeLists.txt
+++ b/projects/voxelization/CMakeLists.txt
@@ -13,7 +13,11 @@ add_executable(voxelization src/main.cpp)
target_sources(voxelization PRIVATE
src/Voxelization.hpp
- src/Voxelization.cpp)
+ src/Voxelization.cpp
+ src/ShadowMapping.hpp
+ src/ShadowMapping.cpp
+ src/BloomAndFlares.hpp
+ src/BloomAndFlares.cpp)
# this should fix the execution path to load local files from the project (for MSVC)
if(MSVC)
diff --git a/projects/voxelization/resources/RadialLUT.png b/projects/voxelization/resources/RadialLUT.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b7056cf2a35c4d41f142e52bbc48dd1a91e4758
--- /dev/null
+++ b/projects/voxelization/resources/RadialLUT.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70d59d4e9c1ce2a077ed60c19c8c4665bf0723c952612a2ca8ec32c55f9ec498
+size 900
diff --git a/projects/voxelization/resources/Sponza/Sponza.bin b/projects/voxelization/resources/Sponza/Sponza.bin
index cfedd26ca5a67b6d0a47d44d13a75e14a141717a..eb0523cb55746451c1b20f25fb4ecfed22ef6047 100644
--- a/projects/voxelization/resources/Sponza/Sponza.bin
+++ b/projects/voxelization/resources/Sponza/Sponza.bin
@@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
-oid sha256:4b809f7a17687dc99e6f41ca1ea32c06eded8779bf34d16f1f565d750b0ffd68
-size 6347696
+oid sha256:232d9c216b72dc0ee6089bc070cf8a12cabecd6a00c1f04aea78ac361da53839
+size 10819832
diff --git a/projects/voxelization/resources/Sponza/Sponza.gltf b/projects/voxelization/resources/Sponza/Sponza.gltf
index 172ea07e21c94465211c860cd805355704cef230..18d697f622eab38c3b3089a56c1680ff4a443171 100644
--- a/projects/voxelization/resources/Sponza/Sponza.gltf
+++ b/projects/voxelization/resources/Sponza/Sponza.gltf
@@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
-oid sha256:5cc0ecad5c4694088ff820e663619c370421afc1323ac487406e8e9b4735d787
-size 713962
+oid sha256:748597f56b7228dddbe4c5d1cb84a35d645941933faf89c4c0f81dd9b602291e
+size 73667
diff --git a/projects/voxelization/resources/Sponza/Textures/Arch_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Arch_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..95900bdf9c8d57666b92929109a6750dc04a548b
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Arch_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8b68080eb4c5709536dfb7858d595d51d4bb725003e11b0f383acf76a7e05a3
+size 521947
diff --git a/projects/voxelization/resources/Sponza/Textures/Arch_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Arch_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..28e407a7c96acc4fbc9e75c7c8d6399914d409e3
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Arch_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86defcb4c007b80b9d23bcc9fdccd994f6a68f710eb75f11396d92faa2fbe368
+size 206244
diff --git a/projects/voxelization/resources/Sponza/Textures/Arch_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Arch_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d1e0df9e5b0613ee476440b7e86d23535d5f4d05
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Arch_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:259b6659cb2681e06ef04becd49298d379f2f25b2cc468acf0c2ade4d190637c
+size 570081
diff --git a/projects/voxelization/resources/Sponza/Textures/Background_Albedo.png b/projects/voxelization/resources/Sponza/Textures/Background_Albedo.png
new file mode 100644
index 0000000000000000000000000000000000000000..668c3b6d389e9675bf8e482a51936fe1dff0c889
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Background_Albedo.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a64b98be19acc30b95d071fb9dd1f0eaaf066612a2c757b32f8b7487f4600e9
+size 1653594
diff --git a/projects/voxelization/resources/Sponza/Textures/Background_Normal.png b/projects/voxelization/resources/Sponza/Textures/Background_Normal.png
new file mode 100644
index 0000000000000000000000000000000000000000..6f03475bdcf3d26f1b152c30680998fbb6dec321
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Background_Normal.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e7fe693f80bbf4b543d3afc614390e498bb84664fd0251c3cfb4e99b4885a12
+size 1299002
diff --git a/projects/voxelization/resources/Sponza/Textures/Background_Roughness.png b/projects/voxelization/resources/Sponza/Textures/Background_Roughness.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f47f6a071463d13bb0f719570e3c53c4a65c079
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Background_Roughness.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15339be54f1f86593a48875dfde6947adf4ba49b3b945619ce3b4fbea64afbd1
+size 791544
diff --git a/projects/voxelization/resources/Sponza/Textures/Bricks_A_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Bricks_A_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..cff7cf6ceb272d99378ce4b7facd09ade9f7c61a
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Bricks_A_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9330cf1d51c8f6924b6c9ce09f2dedb21a82e1c7406c37d49ce95beca40bb3be
+size 564801
diff --git a/projects/voxelization/resources/Sponza/Textures/Bricks_A_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Bricks_A_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..f83f46eb02cbf045886b8867b2dac93321800bf5
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Bricks_A_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0821ec8dc8226fd5ac70f068e134d014a9952276a7100cc7f0660853471b39f6
+size 339486
diff --git a/projects/voxelization/resources/Sponza/Textures/Bricks_A_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Bricks_A_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..da82e3992c1cdac7b90f294809193f4227da08cf
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Bricks_A_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bee42826d56d3ff719c4908c11ef65584fbe19e08273862fde7ec1408e44ba25
+size 530384
diff --git a/projects/voxelization/resources/Sponza/Textures/Ceiling_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Ceiling_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..20f8871aa9bb13d4c2ccc7a0aa9ddddcd226080b
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Ceiling_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5bbd0cbf2da7416d5620514ebb0c4837b0ccc841b649cf4070281aa333ff8520
+size 520162
diff --git a/projects/voxelization/resources/Sponza/Textures/Ceiling_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Ceiling_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8a8fba3de7e4b68e5d5a095cb30442fb30c53be6
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Ceiling_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e309f1e6310dc0bb85df0a5f3b139207876f067378796a7aa666b0bb169587ae
+size 919134
diff --git a/projects/voxelization/resources/Sponza/Textures/Ceiling_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Ceiling_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..59ec4fabc2df618dce40d73a1e71c23e780b0422
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Ceiling_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81b21b9352f1fb9ccfeaf237f8547b985ddbf0cfd7ade7a4a8670b73a72b2cb5
+size 608687
diff --git a/projects/voxelization/resources/Sponza/Textures/Chain_Diff.png b/projects/voxelization/resources/Sponza/Textures/Chain_Diff.png
new file mode 100644
index 0000000000000000000000000000000000000000..9629f2f279c8b2d338724b96538f2858a9f3f4ff
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Chain_Diff.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6df943a0dcf535d9dfb009c2833e0c7dc21939cfe3a2c10316c552b3dc3441b
+size 1077432
diff --git a/projects/voxelization/resources/Sponza/Textures/Chain_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Chain_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..127484f4ff3aa31597262c8e675c9d1f4dc979f1
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Chain_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:763740af8d22f0bfc6a43bd46050ef24bb661833bcace92f1f3326b9d5d7dc16
+size 137384
diff --git a/projects/voxelization/resources/Sponza/Textures/Cloth1_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Cloth1_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..cd117615246364139418024db5474e3e29ccc40b
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Cloth1_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3af8848a1a952ad8cc83199bbda0c095f9ed136be839659aa668f72afac91508
+size 1034060
diff --git a/projects/voxelization/resources/Sponza/Textures/Cloth1_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Cloth1_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e505337ce76a797c4b385c89c25f9486eccab9a8
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Cloth1_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21bb124f5b5d4d5e9c8d9773cd31dedfc41b30eb302af36e7257cf930152908e
+size 486634
diff --git a/projects/voxelization/resources/Sponza/Textures/Cloth2_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Cloth2_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..35885a182fc5cf119afbebbeb2cc060850970731
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Cloth2_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:231d919288db7c977fda3091549195c1bd5197e9e63c039e972da8764f5435c1
+size 844768
diff --git a/projects/voxelization/resources/Sponza/Textures/Cloth2_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Cloth2_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..982536602c4633893fa19c27c0b0e08a8ea0aec8
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Cloth2_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ad0e8a9ca6de602225a527361bc718881de8741bc48927e27259a8803e7fed7
+size 623144
diff --git a/projects/voxelization/resources/Sponza/Textures/ClothBlue1_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/ClothBlue1_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ae58b3bb674bec1f07a3f7de7eb52c8b4c23f4be
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/ClothBlue1_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:005b774a968c1f6af00e4bf97afd668a6a045126a94f524df722ba19edc77d61
+size 1151448
diff --git a/projects/voxelization/resources/Sponza/Textures/ClothBlue2_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/ClothBlue2_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e8597404fcae24e14967eb2220faa1d5cd4d8170
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/ClothBlue2_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:751606c94a5fe5bda3bf6709e7f6a74363bd7902bf2353d54e55ef3b50007487
+size 785678
diff --git a/projects/voxelization/resources/Sponza/Textures/ClothBlue2_Diff_jpg.jpg b/projects/voxelization/resources/Sponza/Textures/ClothBlue2_Diff_jpg.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ae58b3bb674bec1f07a3f7de7eb52c8b4c23f4be
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/ClothBlue2_Diff_jpg.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:005b774a968c1f6af00e4bf97afd668a6a045126a94f524df722ba19edc77d61
+size 1151448
diff --git a/projects/voxelization/resources/Sponza/Textures/ClothGreen1_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/ClothGreen1_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..833de50475dc9d4db7c36e0447bd8e17a5de41f5
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/ClothGreen1_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f55814430f289e89c7d675c3db925eee904fbc566ff83f4b49904de53138e98
+size 1044330
diff --git a/projects/voxelization/resources/Sponza/Textures/ClothGreen2_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/ClothGreen2_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..63ca00ba7ca17e80054fdf35b87aad4227edadef
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/ClothGreen2_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d5fd79619a52db0232edb2287f5f05c0124c304355e3b035a4e48c0871090bf
+size 764529
diff --git a/projects/voxelization/resources/Sponza/Textures/ClothRed1_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/ClothRed1_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..406d620bf21db33765c00f87f3750f73c8df2de0
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/ClothRed1_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23c32277c33d8eac091cd73daf81561ebe3640eede49b037546ed5c244a01347
+size 1079152
diff --git a/projects/voxelization/resources/Sponza/Textures/ClothRed2_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/ClothRed2_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..f5b06c8dcee807f739981bfc061e4cd3d8f0a291
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/ClothRed2_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88861c8c7f10517c1d7942f316aae3b74dc5b8ae2faa2021d9dfe9d2c09fb24f
+size 780166
diff --git a/projects/voxelization/resources/Sponza/Textures/Column_B_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Column_B_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ba6158fe4718103e6f37ee0f1e482e4e5dfc25d8
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Column_B_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:170f6c637ebd71a101244eb4d80c3dcf7063caf89e42053d3114d8aeca755cdf
+size 643517
diff --git a/projects/voxelization/resources/Sponza/Textures/Column_B_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Column_B_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..af99619ce8ff2b71246c00a79d94999c89f40e2e
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Column_B_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46ffc9123ee3ad94b2595843b4446fd67dbf5a2f79dc1e3b4e637f5ea4578630
+size 652476
diff --git a/projects/voxelization/resources/Sponza/Textures/Column_B_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Column_B_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..52c8e41dbc885800512ccc8527932be0f6964c63
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Column_B_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93d495e33d754c5723c910e322ac94108fc753b65af082a19be5252905aa741b
+size 388462
diff --git a/projects/voxelization/resources/Sponza/Textures/Column_C_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Column_C_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..53c725db4dece66f1458bc93dfb95ab20f8927cb
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Column_C_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9edc7c1c73661658cd8ed7733728002d45fecd17cb37a962fb654ff1d8c1933d
+size 665796
diff --git a/projects/voxelization/resources/Sponza/Textures/Column_C_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Column_C_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..9d2c5f3fe9792c825c50743e80969cb3bca660a9
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Column_C_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58942b73c8f209ab9cc6ea174375adfde9c1875cbfe093f993086a0ab6570724
+size 698410
diff --git a/projects/voxelization/resources/Sponza/Textures/Column_C_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Column_C_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..cf4a888d7023a9d23248a68d6217e5e1317c9b46
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Column_C_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06c6480e207ce64f9e7c08df3f7f21638da7da43f77682657f4c823acd8c81a5
+size 193077
diff --git a/projects/voxelization/resources/Sponza/Textures/Column_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Column_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..f6e1fc5dfdbc52d8bf80bd736b6c7881f260b10d
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Column_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c39c9f304c2605be791b4c0a58cd0f8eb20de2dd6a4a4af893c4eb112d158353
+size 518310
diff --git a/projects/voxelization/resources/Sponza/Textures/Column_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Column_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..549b3a7e290e79a4275124ce339c2d7a6b308cb2
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Column_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d54c520da7e60e2a62630e9cf946faf139648a7ab831c4531272238e4ade8fa8
+size 557865
diff --git a/projects/voxelization/resources/Sponza/Textures/Column_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Column_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5c3770a5faebbe1e98df4b39367a87246b0161cc
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Column_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f06c93f8e9f90be44a2e78847e57acec82bd793f58f7be7f86b088150730b88
+size 260119
diff --git a/projects/voxelization/resources/Sponza/Textures/Detail_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Detail_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8ede3e8fff423456faf51cb1419261a33ab708d0
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Detail_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98e4c4a091fea684cd693f3ae7ebe83e491969b501b4cd6e1fdd6a3cc1fa5cab
+size 321375
diff --git a/projects/voxelization/resources/Sponza/Textures/Detail_norm.jpg b/projects/voxelization/resources/Sponza/Textures/Detail_norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..6dad5879bba40f4273658e28f6d7fa3e3d8a663b
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Detail_norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9552937c9fa0481a07dc66768958b4be382544add46d1d66a687af54c51ab6da
+size 547553
diff --git a/projects/voxelization/resources/Sponza/Textures/Detail_spec.jpg b/projects/voxelization/resources/Sponza/Textures/Detail_spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d3918da21cdc2bcb27db235749791c45b1fb88f4
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Detail_spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:967005ccfbf4d38f674df41aebb3e58ac1fdcd91f554ead7acfcc132372f8ec6
+size 551432
diff --git a/projects/voxelization/resources/Sponza/Textures/Fill_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Fill_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..b7dfccb5c93c5d215f3466b9352b6e77f4034555
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Fill_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5562f0e76ca213d72295e48b8a14a59ee1971f58a47f95e5c022a4e78371c5aa
+size 12575
diff --git a/projects/voxelization/resources/Sponza/Textures/Flagpole_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Flagpole_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..43e93c048438d4d57501c198f45d5888d5a478fd
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Flagpole_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbdb7bcced57a005b84b4c3bbf744bae6309804cca51dabd9237e03a72fbc505
+size 399027
diff --git a/projects/voxelization/resources/Sponza/Textures/Flagpole_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Flagpole_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8a8c2891f2c44d175806df7d1451dea97649154a
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Flagpole_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62a52f200082c02a0fbfa25c0bc40ea7d105a21f10d5aa0ec9408c4f45523794
+size 772201
diff --git a/projects/voxelization/resources/Sponza/Textures/Flagpole_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Flagpole_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..145dc9d42327723970227151f945048b34471287
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Flagpole_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d939d2e8bf11c2cf375154129f861b982c786b83db79cb9fde1a2b94b46caf62
+size 682743
diff --git a/projects/voxelization/resources/Sponza/Textures/Floor_A_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Floor_A_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d1c351ca22197a2556ff0acc08c73912f63fdac5
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Floor_A_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34b464edddbd2295b0ee23fa7a7a440a19456888c586acdc47032f841b302abd
+size 573157
diff --git a/projects/voxelization/resources/Sponza/Textures/Floor_A_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Floor_A_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..0304c61dbae476fb226b151d44612fca91892e44
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Floor_A_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a2c2aeb87a490a9bd37a8aa912a00e5f5c13974879fcb4f4f0ef39b17c52a7a
+size 718904
diff --git a/projects/voxelization/resources/Sponza/Textures/Floor_A_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Floor_A_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..90621f970579c5c8e268be5d415cab1162cf5910
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Floor_A_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9158388312a76ba25a40d3b57978e1ace224882e53198a766494d98f9118aeba
+size 313460
diff --git a/projects/voxelization/resources/Sponza/Textures/Flower_Diff.png b/projects/voxelization/resources/Sponza/Textures/Flower_Diff.png
new file mode 100644
index 0000000000000000000000000000000000000000..0f297bbb9581dddb4bc61f8e29c14537a3415736
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Flower_Diff.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75328d1aac87f8539be2456e6a5392cef7c6d08476d75585eafcd334dbeee0c5
+size 1225157
diff --git a/projects/voxelization/resources/Sponza/Textures/Flower_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Flower_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..23b8b1d0bc30d90e0dbf2964b7591e3a4c90c215
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Flower_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81ede4ce51045540817c1efb83dbb65a9a9701f1abd78fa130def51d227162fc
+size 421442
diff --git a/projects/voxelization/resources/Sponza/Textures/Flower_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Flower_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..fc60f6df8ee0a01601294062d585377ec14f28f3
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Flower_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d81efcb42b3a044595ca984cb46d941b159064bddae9a43ed8d9582db68d6b47
+size 280745
diff --git a/projects/voxelization/resources/Sponza/Textures/Lion_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Lion_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..51286b49a1eb9d1e52ad599f1d1a4abccc53d7f7
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Lion_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ea4f9bc86354d363ea8153df9b7593c3bd3da153c53b9624c1fd8a960cb3ebc
+size 599959
diff --git a/projects/voxelization/resources/Sponza/Textures/Lion_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Lion_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..49132519e6e14b0a0964575ad92c86f805500421
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Lion_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f296e43c0d4c92953d4899ea0c38e8af992ba471acc87feb10f08e29a94aaef6
+size 512035
diff --git a/projects/voxelization/resources/Sponza/Textures/Lion_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Lion_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3058c29c325e5768bc3189a8c61548d44d88db55
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Lion_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c26ae9523cfae7a062fd074f74e0ddbb61630772f9a2130489e1d6e4724c38b
+size 281980
diff --git a/projects/voxelization/resources/Sponza/Textures/Roof_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Roof_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..1e9b6f6f9a00a99b4563229f76997abf402bcc7f
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Roof_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfa17f2dee2cd2d850585673d19d5cda477a63e21659b346d8730e80edd3b347
+size 822373
diff --git a/projects/voxelization/resources/Sponza/Textures/Roof_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Roof_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..88ee02405bb090eed4ea2b658d0adcb93b1a8ed6
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Roof_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5166a5fba339e44a9d197dedc168683971f8acb2156034248a80674cbba0dd5
+size 1607263
diff --git a/projects/voxelization/resources/Sponza/Textures/Roof_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Roof_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..dccdb78a2b439240d6cb3d79ce1694e53f83217f
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Roof_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e90e94cadf80528a3df3496035d3c77900eba24d88b1c1d31c9dce77990fc44
+size 872255
diff --git a/projects/voxelization/resources/Sponza/Textures/Shield_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Shield_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..da701b850fd9bb49714263dba7c0d2681808ad5a
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Shield_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70d85bff3bc017177124942ae187db117ba2588e490746f440f2cef085852956
+size 357112
diff --git a/projects/voxelization/resources/Sponza/Textures/Shield_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Shield_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..c918da16e61180632dae222a622bd8d479ff9031
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Shield_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cbd61fcb8047f1c21450eff05207b29d71824edd75483267b5fbc2f7b21378c
+size 329124
diff --git a/projects/voxelization/resources/Sponza/Textures/Shield_diff.jpg b/projects/voxelization/resources/Sponza/Textures/Shield_diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..90aa71962d62e0370f1d3550fc35781c54a466bf
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Shield_diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73a94a12fb0a9ab4c75e40996c9a2d49ac45ac18a8c8ae81d5ceb1c8ae52d6dc
+size 362437
diff --git a/projects/voxelization/resources/Sponza/Textures/Thorn_Diff.png b/projects/voxelization/resources/Sponza/Textures/Thorn_Diff.png
new file mode 100644
index 0000000000000000000000000000000000000000..cd52793a05b4f0827299d86c7446315ce67c1c68
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Thorn_Diff.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6fbdbf67d3501831ad3a4e2adbf3d27e4c3d13ba1d655e5861c3f39b5f899f65
+size 2427921
diff --git a/projects/voxelization/resources/Sponza/Textures/Thorn_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Thorn_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d85686c7aa40b03a94d00fa86dcd1f41681f1e1f
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Thorn_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc5bf5f3091b548f1dfe40410b1aa1e2e55d82e2d77ba57dbd1f92955a0d8ff8
+size 413837
diff --git a/projects/voxelization/resources/Sponza/Textures/Thorn_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Thorn_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..dc414f0ea13433f7fe9832f4a64d0514ae9a2239
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Thorn_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da2a0b308b4d6d57ffbcf4bb7509d4afe91156d5d86d0396e83d7cac883a4857
+size 668962
diff --git a/projects/voxelization/resources/Sponza/Textures/VaseRound_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/VaseRound_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..74e6d243f6da2015398ef9a08de663c59f32c329
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/VaseRound_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:430758549ba2189d94f06abeaae092bfc0a1d8c22afc56f5caf3f99c5ee7407c
+size 572245
diff --git a/projects/voxelization/resources/Sponza/Textures/VaseRound_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/VaseRound_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..154b1fa17729990b54b368febb55a259b7a47292
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/VaseRound_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8af8fb0810bf3493242491da44f7ae14f7c0bfa6cbacea4be01f6f4261db4559
+size 618837
diff --git a/projects/voxelization/resources/Sponza/Textures/VaseRound_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/VaseRound_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..97c19f41117e9a3aaec02885b236349c8ba9c6ca
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/VaseRound_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12e1f2ea3c2714a6ec455fa8e623a702e33ef95765ebd09f7874a68fa55fd104
+size 399963
diff --git a/projects/voxelization/resources/Sponza/Textures/Vase_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Vase_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..4d53ec1a796184e24893aff99f53652d08bd4f47
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Vase_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1da7664b7b88ae58386a6e6b5eca2829537818061d704f002356d8fc483c1a28
+size 531156
diff --git a/projects/voxelization/resources/Sponza/Textures/Vase_Hanging_Diff.jpg b/projects/voxelization/resources/Sponza/Textures/Vase_Hanging_Diff.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..149a0f1c47e15ebfc2a9de474e8dda46ed3ab2de
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Vase_Hanging_Diff.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f849f0510ca0df66ba1cba2380a6a1b481444d9e64b68da6b2ce202b54d9cec
+size 302363
diff --git a/projects/voxelization/resources/Sponza/Textures/Vase_Hanging_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Vase_Hanging_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..bcdd65e4b718c0dc7e74f03aa50cac22f10febea
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Vase_Hanging_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b93291121303b5a24a488a3e29e0645a24bb471413cfd25c0917d306dff1d038
+size 208352
diff --git a/projects/voxelization/resources/Sponza/Textures/Vase_Hanging_Spec.jpg b/projects/voxelization/resources/Sponza/Textures/Vase_Hanging_Spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8976a203dfe463d121d48e743b3ecb662ac52d09
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Vase_Hanging_Spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c288a37ed8373d1132644873624b096a72ba81d03cda601e050a5de24ba13c39
+size 104626
diff --git a/projects/voxelization/resources/Sponza/Textures/Vase_Norm.jpg b/projects/voxelization/resources/Sponza/Textures/Vase_Norm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..de5758090ab8ab0aaa374110aa08df6c7f53d599
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Vase_Norm.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:728dd0fe3b570103e51dbfcc1eac64ad09916a7a31603c62a4090a2f2afaa6f8
+size 876227
diff --git a/projects/voxelization/resources/Sponza/Textures/Vase_spec.jpg b/projects/voxelization/resources/Sponza/Textures/Vase_spec.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..0cce3ebf638a3ca932bca8b28c31b8474f123349
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/Vase_spec.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb09708202859d08764601acc9c9ea3b5254b2c4fd39dcc6b6055768c77aee9b
+size 370061
diff --git a/projects/voxelization/resources/Sponza/Textures/white.png b/projects/voxelization/resources/Sponza/Textures/white.png
new file mode 100644
index 0000000000000000000000000000000000000000..98e867371da9926f451d5754604bc97b3186296a
--- /dev/null
+++ b/projects/voxelization/resources/Sponza/Textures/white.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2ab2939dda535ad28779e41c20c98368f630f29c5824a0a5a430f47b3b6da12
+size 951
diff --git a/projects/voxelization/resources/Sponza/background.png b/projects/voxelization/resources/Sponza/background.png
deleted file mode 100644
index b64def129da38f4e23d89e21b4af1039008a4327..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/background.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f5b5f900ff8ed83a31750ec8e428b5b91273794ddcbfc4e4b8a6a7e781f8c686
-size 1417666
diff --git a/projects/voxelization/resources/Sponza/chain_texture.png b/projects/voxelization/resources/Sponza/chain_texture.png
deleted file mode 100644
index c1e1768cff78e0614ad707eca8602a4c4edab5e5..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/chain_texture.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d8362cfd472880daeaea37439326a4651d1338680ae69bb2513fc6b17c8de7d4
-size 490895
diff --git a/projects/voxelization/resources/Sponza/lion.png b/projects/voxelization/resources/Sponza/lion.png
deleted file mode 100644
index c49c7f0ed31e762e19284d0d3624fbc47664e56b..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/lion.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9f882f746c3a9cd51a9c6eedc1189b97668721d91a3fe49232036e789912c652
-size 2088728
diff --git a/projects/voxelization/resources/Sponza/spnza_bricks_a_diff.png b/projects/voxelization/resources/Sponza/spnza_bricks_a_diff.png
deleted file mode 100644
index cde4c7a6511e9a5f03c63ad996437fcdba3ce2df..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/spnza_bricks_a_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b94219c2f5f943f3f4715c74e7d1038bf0ab3b3b3216a758eaee67f875df0851
-size 1928829
diff --git a/projects/voxelization/resources/Sponza/sponza_arch_diff.png b/projects/voxelization/resources/Sponza/sponza_arch_diff.png
deleted file mode 100644
index bcd9bda2918d226039f9e2d03902d377b706fab6..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_arch_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c0df2c8a01b2843b1c792b494f7173cdbc4f834840fc2177af3e5d690fceda57
-size 1596151
diff --git a/projects/voxelization/resources/Sponza/sponza_ceiling_a_diff.png b/projects/voxelization/resources/Sponza/sponza_ceiling_a_diff.png
deleted file mode 100644
index 59de631ffac4414cabf69b2dc794c46fc187d6cb..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_ceiling_a_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ab6c187a81aa68f4eba30119e17fce2e4882a9ec320f70c90482dbe9da82b1c6
-size 1872074
diff --git a/projects/voxelization/resources/Sponza/sponza_column_a_diff.png b/projects/voxelization/resources/Sponza/sponza_column_a_diff.png
deleted file mode 100644
index 01a82432d3f9939bbefe850bdb900f1ff9a3f6db..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_column_a_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2c291507e2808bb83e160ab4b020689817df273baad3713a9ad19ac15fac6826
-size 1840992
diff --git a/projects/voxelization/resources/Sponza/sponza_column_b_diff.png b/projects/voxelization/resources/Sponza/sponza_column_b_diff.png
deleted file mode 100644
index 10a660cce2a5a9b8997772c746058ce23e7d45d7..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_column_b_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2820b0267c4289c6cedbb42721792a57ef244ec2d0935941011c2a7d3fe88a9b
-size 2170433
diff --git a/projects/voxelization/resources/Sponza/sponza_column_c_diff.png b/projects/voxelization/resources/Sponza/sponza_column_c_diff.png
deleted file mode 100644
index bc46fd979044a938d3adca7601689e71504e48bf..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_column_c_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a0bc993ff59865468ef4530798930c7dfefb07482d71db45bc2a520986b27735
-size 2066950
diff --git a/projects/voxelization/resources/Sponza/sponza_curtain_blue_diff.png b/projects/voxelization/resources/Sponza/sponza_curtain_blue_diff.png
deleted file mode 100644
index 384c8c2c051160d530eb3ac8b05c9c60752a2d2b..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_curtain_blue_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b85c6bb3cd5105f48d3812ec8e7a1068521ce69e917300d79e136e19d45422fb
-size 9510905
diff --git a/projects/voxelization/resources/Sponza/sponza_curtain_diff.png b/projects/voxelization/resources/Sponza/sponza_curtain_diff.png
deleted file mode 100644
index af842e9f5fe18c1f609875e00899a6770fa4488b..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_curtain_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:563c56bdbbee395a6ef7f0c51c8ac9223c162e517b4cdba0d4654e8de27c98d8
-size 9189263
diff --git a/projects/voxelization/resources/Sponza/sponza_curtain_green_diff.png b/projects/voxelization/resources/Sponza/sponza_curtain_green_diff.png
deleted file mode 100644
index 6c9b6391a199407637fa71033d79fb58b8b4f0d7..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_curtain_green_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:238fe1c7f481388d1c1d578c2da8d411b99e8f0030ab62060a306db333124476
-size 8785458
diff --git a/projects/voxelization/resources/Sponza/sponza_details_diff.png b/projects/voxelization/resources/Sponza/sponza_details_diff.png
deleted file mode 100644
index 12656686362c3e0a297e060491f33bd7351551f9..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_details_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cb1223b3bb82f8757e7df25a6891f1239cdd7ec59990340e952fb2d6b7ea570c
-size 1522643
diff --git a/projects/voxelization/resources/Sponza/sponza_fabric_blue_diff.png b/projects/voxelization/resources/Sponza/sponza_fabric_blue_diff.png
deleted file mode 100644
index 879d16ef84722a4fc13e83a771778de326e4bc54..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_fabric_blue_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:467d290bf5d4b2a017da140ba9e244ed8a8a9be5418a9ac9bcb4ad572ae2d7ab
-size 2229440
diff --git a/projects/voxelization/resources/Sponza/sponza_fabric_diff.png b/projects/voxelization/resources/Sponza/sponza_fabric_diff.png
deleted file mode 100644
index 3311287a219d2148620b87fe428fea071688d051..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_fabric_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1594f59cc2848db26add47361f4e665e3d8afa147760ed915d839fea42b20287
-size 2267382
diff --git a/projects/voxelization/resources/Sponza/sponza_fabric_green_diff.png b/projects/voxelization/resources/Sponza/sponza_fabric_green_diff.png
deleted file mode 100644
index de110f369004388dae4cd5067c63428db3a07834..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_fabric_green_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:902b87faab221173bf370cea7c74cb9060b4d870ac6316b190dafded1cb12993
-size 2258220
diff --git a/projects/voxelization/resources/Sponza/sponza_flagpole_diff.png b/projects/voxelization/resources/Sponza/sponza_flagpole_diff.png
deleted file mode 100644
index 5f6e0812a0df80346318baa3cb50a6888afc58f8..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_flagpole_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bfffb62e770959c725d0f3db6dc7dbdd46a380ec55ef884dab94d44ca017b438
-size 1425673
diff --git a/projects/voxelization/resources/Sponza/sponza_floor_a_diff.png b/projects/voxelization/resources/Sponza/sponza_floor_a_diff.png
deleted file mode 100644
index 788ed764f79ba724f04a2d603076a5b85013e188..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_floor_a_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a16f9230fa91f9f31dfca6216ce205f1ef132d44f3b012fbf6efc0fba69770ab
-size 1996838
diff --git a/projects/voxelization/resources/Sponza/sponza_roof_diff.png b/projects/voxelization/resources/Sponza/sponza_roof_diff.png
deleted file mode 100644
index c5b84261fdd1cc776a94b3ce398c7806b895f9a3..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_roof_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7fc412138c20da19f8173e53545e771f4652558dff624d4dc67143e40efe562b
-size 2320533
diff --git a/projects/voxelization/resources/Sponza/sponza_thorn_diff.png b/projects/voxelization/resources/Sponza/sponza_thorn_diff.png
deleted file mode 100644
index 7a9142674a7d4a6f94a48c5152cf0300743b597a..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/sponza_thorn_diff.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a73a17c883cd0d0d67cfda2dc4118400a916366c05b9a5ac465f0c8b30fd9c8e
-size 635001
diff --git a/projects/voxelization/resources/Sponza/vase_dif.png b/projects/voxelization/resources/Sponza/vase_dif.png
deleted file mode 100644
index 61236a81cb324af8797b05099cd264cefe189e56..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/vase_dif.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:53d06f52bf9e59df4cf00237707cca76c4f692bda61a62b06a30d321311d6dd9
-size 1842101
diff --git a/projects/voxelization/resources/Sponza/vase_hanging.png b/projects/voxelization/resources/Sponza/vase_hanging.png
deleted file mode 100644
index 36a3cee71d8213225090c74f8c0dce33b9d44378..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/vase_hanging.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a9d10b4f27a3c9a78d5bac882fdd4b6a6987c262f48fa490670fe5e235951e31
-size 1432804
diff --git a/projects/voxelization/resources/Sponza/vase_plant.png b/projects/voxelization/resources/Sponza/vase_plant.png
deleted file mode 100644
index 7ad95e702e229f1ebd803e5203a266d15f2c07b9..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/vase_plant.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d2087371ff02212fb7014b6daefa191cf5676d2227193fff261a5d02f554cb8e
-size 998089
diff --git a/projects/voxelization/resources/Sponza/vase_round.png b/projects/voxelization/resources/Sponza/vase_round.png
deleted file mode 100644
index c17953abc000c44b8991e23c136c2b67348f3d1b..0000000000000000000000000000000000000000
--- a/projects/voxelization/resources/Sponza/vase_round.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:aa23d48d492d5d4ada2ddb27d1ef22952b214e6eb3b301c65f9d88442723d20a
-size 1871399
diff --git a/projects/voxelization/resources/lensDirt.jpg b/projects/voxelization/resources/lensDirt.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..f941567527fe92f23aa6955e15ba95dc46881dad
--- /dev/null
+++ b/projects/voxelization/resources/lensDirt.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95982351ecf3d4d129d17612b40a8092944a285c0bffdd74d4886dd8489695ca
+size 107603
diff --git a/projects/voxelization/resources/shaders/bloomDownsample.comp b/projects/voxelization/resources/shaders/bloomDownsample.comp
new file mode 100644
index 0000000000000000000000000000000000000000..2ab00c7c92798769153634f3479c5b7f3fb61d94
--- /dev/null
+++ b/projects/voxelization/resources/shaders/bloomDownsample.comp
@@ -0,0 +1,76 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(set=0, binding=0) uniform texture2D inBlurImage;
+layout(set=0, binding=1) uniform sampler inImageSampler;
+layout(set=0, binding=2, r11f_g11f_b10f) uniform writeonly image2D outBlurImage;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+
+void main()
+{
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outBlurImage)))){
+ return;
+ }
+
+ ivec2 pixel_coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 pixel_size = vec2(1.0f) / imageSize(outBlurImage);
+ vec2 UV = pixel_coord.xy * pixel_size;
+ vec2 UV_offset = UV + 0.5f * pixel_size;
+
+ vec2 color_fetches[13] = {
+ // center neighbourhood (RED)
+ vec2(-1, 1), // LT
+ vec2(-1, -1), // LB
+ vec2( 1, -1), // RB
+ vec2( 1, 1), // RT
+
+ vec2(-2, 2), // LT
+ vec2( 0, 2), // CT
+ vec2( 2, 2), // RT
+
+ vec2(0 ,-2), // LC
+ vec2(0 , 0), // CC
+ vec2(2, 0), // CR
+
+ vec2(-2, -2), // LB
+ vec2(0 , -2), // CB
+ vec2(2 , -2) // RB
+ };
+
+ float color_weights[13] = {
+ // 0.5f
+ 1.f/8.f,
+ 1.f/8.f,
+ 1.f/8.f,
+ 1.f/8.f,
+
+ // 0.125f
+ 1.f/32.f,
+ 1.f/16.f,
+ 1.f/32.f,
+
+ // 0.25f
+ 1.f/16.f,
+ 1.f/8.f,
+ 1.f/16.f,
+
+ // 0.125f
+ 1.f/32.f,
+ 1.f/16.f,
+ 1.f/32.f
+ };
+
+ vec3 sampled_color = vec3(0.0f);
+
+ for(uint i = 0; i < 13; i++)
+ {
+ vec2 color_fetch = UV_offset + color_fetches[i] * pixel_size;
+ vec3 color = texture(sampler2D(inBlurImage, inImageSampler), color_fetch).rgb;
+ color *= color_weights[i];
+ sampled_color += color;
+ }
+
+ imageStore(outBlurImage, pixel_coord, vec4(sampled_color, 1.f));
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/bloomFlaresComposite.comp b/projects/voxelization/resources/shaders/bloomFlaresComposite.comp
new file mode 100644
index 0000000000000000000000000000000000000000..57174b73ae3b58023d01defd26f636e13cb4709c
--- /dev/null
+++ b/projects/voxelization/resources/shaders/bloomFlaresComposite.comp
@@ -0,0 +1,89 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(set=0, binding=0) uniform texture2D blurImage;
+layout(set=0, binding=1) uniform texture2D lensImage;
+layout(set=0, binding=2) uniform sampler linearSampler;
+layout(set=0, binding=3, r11f_g11f_b10f) uniform image2D colorBuffer;
+layout(set=0, binding=4) uniform texture2D radialLUT;
+layout(set=0, binding=5) uniform sampler radialLUTSampler;
+layout(set=0, binding=6) uniform texture2D dirtTexture;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+layout( push_constant ) uniform constants{
+ vec3 cameraForward;
+};
+
+float starburst(vec2 uv){
+ vec2 toCenter = vec2(0.5) - uv;
+ float d2 = dot(toCenter, toCenter);
+ float falloff = clamp(pow(d2 * 2, 2.5), 0, 1);
+
+ float cosTheta = acos(normalize(toCenter).x) * sign(toCenter.y);
+ cosTheta *= 4;
+
+ float thetaOffset = cameraForward.x + cameraForward.y;
+ thetaOffset *= 10;
+ cosTheta += thetaOffset;
+
+ float burst = texture(sampler2D(radialLUT, radialLUTSampler), vec2(cosTheta, 0.5)).r;
+ burst = pow(burst, 2);
+ return mix(1, burst, falloff);
+}
+
+float getLensDirtWeight(vec2 uv){
+ vec2 targetTextureRes = imageSize(colorBuffer);
+ float targetAspectRatio = targetTextureRes.x / targetTextureRes.y;
+
+ vec2 dirtTextureRes = textureSize(sampler2D(dirtTexture, linearSampler), 0);
+ float dirtAspectRatio = dirtTextureRes.x / dirtTextureRes.y;
+
+ uv.x *= targetAspectRatio / dirtAspectRatio;
+ float dirt = texture(sampler2D(dirtTexture, radialLUTSampler), uv).r;
+ float dirtStrength = 0.4f;
+
+ // manually looked up in gimp, must be adjusted when changing dirt texture
+ float dirtMean = 0.132;
+ // make sure no energy is lost
+ // otherwise bloom is darkened when the dirt increases
+ dirt /= dirtMean;
+
+ return mix(1, dirt, dirtStrength);
+}
+
+void main()
+{
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(colorBuffer)))){
+ return;
+ }
+
+ ivec2 pixel_coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 pixel_size = vec2(1.0f) / imageSize(colorBuffer);
+ vec2 UV = pixel_coord.xy * pixel_size;
+
+ vec4 composite_color = vec4(0.0f);
+
+ vec3 blur_color = texture(sampler2D(blurImage, linearSampler), UV).rgb;
+ vec3 lens_color = texture(sampler2D(lensImage, linearSampler), UV).rgb;
+ vec3 main_color = imageLoad(colorBuffer, pixel_coord).rgb;
+
+ // composite blur and lens features
+ float bloom_weight = 0.06f;
+ float lens_weight = 0.02f;
+ float main_weight = 1 - (bloom_weight + lens_weight);
+
+ lens_color *= starburst(UV);
+
+ float lensDirtWeight = getLensDirtWeight(UV);
+ bloom_weight *= lensDirtWeight;
+ lens_weight *= lensDirtWeight;
+
+ composite_color.rgb = blur_color * bloom_weight +
+ lens_color * lens_weight +
+ main_color * main_weight;
+
+ //composite_color.rgb = vec3(1) * starburst(UV);
+
+ imageStore(colorBuffer, pixel_coord, composite_color);
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/bloomUpsample.comp b/projects/voxelization/resources/shaders/bloomUpsample.comp
new file mode 100644
index 0000000000000000000000000000000000000000..0ddeedb5b5af9e476dc19012fed6430544006c0e
--- /dev/null
+++ b/projects/voxelization/resources/shaders/bloomUpsample.comp
@@ -0,0 +1,45 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(set=0, binding=0) uniform texture2D inUpsampleImage;
+layout(set=0, binding=1) uniform sampler inImageSampler;
+layout(set=0, binding=2, r11f_g11f_b10f) uniform image2D outUpsampleImage;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+void main()
+{
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outUpsampleImage)))){
+ return;
+ }
+
+
+ ivec2 pixel_coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 pixel_size = vec2(1.0f) / imageSize(outUpsampleImage);
+ vec2 UV = pixel_coord.xy * pixel_size;
+
+ const float gauss_kernel[3] = {1.f, 2.f, 1.f};
+ const float gauss_weight = 16.f;
+
+ vec3 sampled_color = vec3(0.f);
+
+ for(int i = -1; i <= 1; i++)
+ {
+ for(int j = -1; j <= 1; j++)
+ {
+ vec2 sample_location = UV + vec2(j, i) * pixel_size;
+ vec3 color = texture(sampler2D(inUpsampleImage, inImageSampler), sample_location).rgb;
+ color *= gauss_kernel[j+1];
+ color *= gauss_kernel[i+1];
+ color /= gauss_weight;
+
+ sampled_color += color;
+ }
+ }
+
+ //vec3 prev_color = imageLoad(outUpsampleImage, pixel_coord).rgb;
+ //float bloomRimStrength = 0.75f; // adjust this to change strength of bloom
+ //sampled_color = mix(prev_color, sampled_color, bloomRimStrength);
+
+ imageStore(outUpsampleImage, pixel_coord, vec4(sampled_color, 1.f));
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/brdf.inc b/projects/voxelization/resources/shaders/brdf.inc
new file mode 100644
index 0000000000000000000000000000000000000000..4cf334eaceedd18815ab928aed38d5f8d3f51c1e
--- /dev/null
+++ b/projects/voxelization/resources/shaders/brdf.inc
@@ -0,0 +1,31 @@
+#ifndef BRDF_INC
+#define BRDF_INC
+
+const float pi = 3.1415;
+
+vec3 lambertBRDF(vec3 albedo){
+ return albedo / pi;
+}
+
+vec3 fresnelSchlick(float cosTheta, vec3 f0){
+ return f0 + (vec3(1) - f0) * pow(1 - cosTheta, 5);
+}
+
+float GGXDistribution(float r, float NoH){
+ float r2 = r * r;
+ float denom = pi * pow(NoH * NoH * (r2 - 1) + 1, 2);
+ return r2 / max(denom, 0.00001);
+}
+
+float GGXSmithShadowingPart(float r, float cosTheta){
+ float nom = cosTheta * 2;
+ float r2 = r * r;
+ float denom = cosTheta + sqrt(r2 + (1 - r2) * cosTheta * cosTheta);
+ return nom / max(denom, 0.00001);
+}
+
+float GGXSmithShadowing(float r, float NoV, float NoL){
+ return GGXSmithShadowingPart(r, NoV) * GGXSmithShadowingPart(r, NoL);
+}
+
+#endif // #ifndef BRDF_INC
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/depthPrepass.frag b/projects/voxelization/resources/shaders/depthPrepass.frag
new file mode 100644
index 0000000000000000000000000000000000000000..5e2f7a092ca300af40cc039608a44d080c28730f
--- /dev/null
+++ b/projects/voxelization/resources/shaders/depthPrepass.frag
@@ -0,0 +1,20 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_GOOGLE_include_directive : enable
+
+#include "perMeshResources.inc"
+
+layout(location = 0) in vec2 passUV;
+
+layout(location = 0) out vec4 outColor; // only used for alpha to coverage, not actually written to
+
+// coverage to alpha techniques explained in: https://bgolus.medium.com/anti-aliased-alpha-test-the-esoteric-alpha-to-coverage-8b177335ae4f
+void main() {
+ float alpha = texture(sampler2D(albedoTexture, textureSampler), passUV).a;
+ float alphaCutoff = 0.5;
+
+ // scale alpha to one pixel width
+ alpha = (alpha - alphaCutoff) / max(fwidth(alpha), 0.0001) + 0.5;
+
+ outColor.a = alpha;
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/depthPrepass.vert b/projects/voxelization/resources/shaders/depthPrepass.vert
new file mode 100644
index 0000000000000000000000000000000000000000..4bb3500eb59214e30fce84862e181fd7e24b7340
--- /dev/null
+++ b/projects/voxelization/resources/shaders/depthPrepass.vert
@@ -0,0 +1,18 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+#extension GL_GOOGLE_include_directive : enable
+
+layout(location = 0) in vec3 inPosition;
+layout(location = 2) in vec2 inUV;
+
+layout(location = 0) out vec2 passUV;
+
+layout( push_constant ) uniform constants{
+ mat4 mvp;
+};
+
+void main() {
+ gl_Position = mvp * vec4(inPosition, 1.0);
+ passUV = inUV;
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/depthToMoments.comp b/projects/voxelization/resources/shaders/depthToMoments.comp
new file mode 100644
index 0000000000000000000000000000000000000000..5a78d0cb9b748187d12057708fcd0de7658a61ed
--- /dev/null
+++ b/projects/voxelization/resources/shaders/depthToMoments.comp
@@ -0,0 +1,36 @@
+#version 450
+#extension GL_GOOGLE_include_directive : enable
+#extension GL_ARB_texture_multisample : enable
+
+#include "shadowMapping.inc"
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+layout(set=0, binding=0) uniform texture2DMS srcTexture;
+layout(set=0, binding=1) uniform sampler depthSampler;
+layout(set=0, binding=2, rgba16) uniform image2D outImage;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+layout( push_constant ) uniform constants{
+ int msaaCount;
+};
+
+void main(){
+
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outImage)))){
+ return;
+ }
+ ivec2 uv = ivec2(gl_GlobalInvocationID.xy);
+
+ float z = 0;
+ for(int i = 0; i < msaaCount; i++){
+ z += texelFetch(sampler2DMS(srcTexture, depthSampler), uv, i).r;
+ }
+ z /= msaaCount;
+
+ float z2 = z*z;
+ vec4 moments = vec4(z, z2, z2*z, z2*z2);
+ vec4 momentsQuantized = quantizeMoments(moments);
+ imageStore(outImage, uv, momentsQuantized);
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/lensFlares.comp b/projects/voxelization/resources/shaders/lensFlares.comp
new file mode 100644
index 0000000000000000000000000000000000000000..afcad375c1cd3e8f547ad2386b6f1d7bdfdfa85a
--- /dev/null
+++ b/projects/voxelization/resources/shaders/lensFlares.comp
@@ -0,0 +1,106 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(set=0, binding=0) uniform texture2D blurBuffer;
+layout(set=0, binding=1) uniform sampler linearSampler;
+layout(set=0, binding=2, r11f_g11f_b10f) uniform image2D lensBuffer;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+vec3 sampleColorChromaticAberration(vec2 _uv)
+{
+ vec2 toCenter = (vec2(0.5) - _uv);
+
+ vec3 colorScales = vec3(-1, 0, 1);
+ float aberrationScale = 0.15;
+ vec3 scaleFactors = colorScales * aberrationScale;
+
+ float r = texture(sampler2D(blurBuffer, linearSampler), _uv + toCenter * scaleFactors.r).r;
+ float g = texture(sampler2D(blurBuffer, linearSampler), _uv + toCenter * scaleFactors.g).g;
+ float b = texture(sampler2D(blurBuffer, linearSampler), _uv + toCenter * scaleFactors.b).b;
+ return vec3(r, g, b);
+}
+
+// _uv assumed to be flipped UV coordinates!
+vec3 ghost_vectors(vec2 _uv)
+{
+ vec2 ghost_vec = (vec2(0.5f) - _uv);
+
+ const uint c_ghost_count = 8;
+ const float c_ghost_spacing = length(ghost_vec) / c_ghost_count;
+
+ ghost_vec *= c_ghost_spacing;
+
+ vec3 ret_color = vec3(0.0f);
+
+ for (uint i = 0; i < c_ghost_count; ++i)
+ {
+ // sample scene color
+ vec2 s_uv = fract(_uv + ghost_vec * vec2(i));
+ vec3 s = sampleColorChromaticAberration(s_uv);
+
+ // tint/weight
+ float d = distance(s_uv, vec2(0.5));
+ float weight = 1.0f - smoothstep(0.0f, 0.75f, d);
+ s *= weight;
+
+ ret_color += s;
+ }
+
+ ret_color /= c_ghost_count;
+ return ret_color;
+}
+
+vec3 halo(vec2 _uv)
+{
+ float c_aspect_ratio = float(imageSize(lensBuffer).x) / float(imageSize(lensBuffer).y);
+ c_aspect_ratio *= 0.55;
+ const float c_radius = 0.5f;
+ const float c_halo_thickness = 0.15f;
+
+ vec2 halo_vec = vec2(0.5) - _uv;
+ halo_vec.x /= c_aspect_ratio;
+ halo_vec = normalize(halo_vec);
+ halo_vec.x *= c_aspect_ratio;
+
+
+ vec2 w_uv = (_uv - vec2(0.5, 0.0)) * vec2(c_aspect_ratio, 1.0) + vec2(0.5, 0.0);
+ //vec2 w_uv = _uv;
+ float d = distance(w_uv, vec2(0.5)); // distance to center
+
+ float distance_to_halo = abs(d - c_radius);
+
+ float halo_weight = 0.0f;
+ if(abs(d - c_radius) <= c_halo_thickness)
+ {
+ float distance_to_border = c_halo_thickness - distance_to_halo;
+ halo_weight = distance_to_border / c_halo_thickness;
+
+ halo_weight = pow(clamp(halo_weight + 0.1, 0, 1), 2);
+ }
+
+ return sampleColorChromaticAberration(_uv + halo_vec) * halo_weight;
+}
+
+
+
+void main()
+{
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(lensBuffer)))){
+ return;
+ }
+
+ ivec2 pixel_coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 pixel_size = vec2(1.0f) / imageSize(lensBuffer);
+ vec2 UV = pixel_coord.xy * pixel_size;
+
+ vec2 flipped_UV = vec2(1.0f) - UV;
+
+ vec3 color = vec3(0.0f);
+
+ color += ghost_vectors(flipped_UV);
+ color += halo(UV);
+ color *= 0.5f;
+
+ imageStore(lensBuffer, pixel_coord, vec4(color, 0.0f));
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/lightInfo.inc b/projects/voxelization/resources/shaders/lightInfo.inc
index 4345d4f1504d27df7392b34bcaf17efdcfecef33..a87f9ce7bebc1db1688dd20dd80608e99925755a 100644
--- a/projects/voxelization/resources/shaders/lightInfo.inc
+++ b/projects/voxelization/resources/shaders/lightInfo.inc
@@ -1,6 +1,12 @@
+#ifndef LIGHT_INFO_INC
+#define LIGHT_INFO_INC
+
struct LightInfo{
- vec3 L; float padding;
- vec3 sunColor;
- float sunStrength;
- mat4 lightMatrix;
-};
\ No newline at end of file
+ vec3 L;
+ float padding;
+ vec3 sunColor;
+ float sunStrength;
+ mat4 lightMatrix;
+};
+
+#endif // #ifndef LIGHT_INFO_INC
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/luma.inc b/projects/voxelization/resources/shaders/luma.inc
new file mode 100644
index 0000000000000000000000000000000000000000..17b3b282830ab155ce62e9b1394c0985ceccecd9
--- /dev/null
+++ b/projects/voxelization/resources/shaders/luma.inc
@@ -0,0 +1,8 @@
+#ifndef LUMA_INC
+#define LUMA_INC
+
+float computeLuma(vec3 c){
+ return dot(c, vec3(0.21, 0.72, 0.07));
+}
+
+#endif // #ifndef LUMA_INC
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/msaa4XResolve.comp b/projects/voxelization/resources/shaders/msaa4XResolve.comp
new file mode 100644
index 0000000000000000000000000000000000000000..8bb1a946e3ba43f4e80f21f6bd730e020276f2d8
--- /dev/null
+++ b/projects/voxelization/resources/shaders/msaa4XResolve.comp
@@ -0,0 +1,83 @@
+#version 450
+#extension GL_ARB_texture_multisample : enable
+#extension GL_GOOGLE_include_directive : enable
+
+layout(set=0, binding=0) uniform texture2DMS srcTexture;
+layout(set=0, binding=1) uniform sampler MSAASampler;
+layout(set=0, binding=2, r11f_g11f_b10f) uniform image2D outImage;
+
+#include "luma.inc"
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+vec3 tonemap(vec3 c){
+ return c / (1 + computeLuma(c));
+}
+
+vec3 tonemapReverse(vec3 c){
+ return c / (1 - computeLuma(c));
+}
+
+float reconstructionFilter(float d){
+ // gauß filter, tuned so that distance of one has weight around 20%
+ float a = 1.6;
+ return exp(-a * d*d);
+}
+
+void main(){
+
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outImage)))){
+ return;
+ }
+ ivec2 uv = ivec2(gl_GlobalInvocationID.xy);
+
+ vec2 samplePositions[4] = {
+ vec2(0.375, 0.125),
+ vec2(0.875, 0.375),
+ vec2(0.125, 0.625),
+ vec2(0.625, 0.875)};
+
+ vec3 color = vec3(0);
+ float wTotal = 0;
+
+ // four samples from main pixel
+ for(int i = 0; i < 4; i++){
+ vec3 msaaSample = texelFetch(sampler2DMS(srcTexture, MSAASampler), uv, i).rgb;
+ float d = distance(vec2(0.5), samplePositions[i]);
+ float w = reconstructionFilter(d);
+ color += tonemap(msaaSample) * w;
+ wTotal += w;
+ }
+
+ ivec2 neighbourOffsets[4] = {
+ ivec2( 1, 0), // right
+ ivec2(-1, 0), // left
+ ivec2( 0, 1), // top
+ ivec2( 0, -1) // bot
+ };
+
+ int neighbourSampleIndices[8] = {
+ 0, 2, // left samples of right neighbour
+ 1, 3, // right samples of left neighbour
+ 2, 3, // bot samples of top neighbour
+ 0, 1 // top samples of bot neighbour
+ };
+
+ // two additional samples from each neighbour
+ for(int neighbour = 0; neighbour < 4; neighbour++){
+ for(int i = 0; i < 2; i++){
+ int sampleIndex = neighbourSampleIndices[neighbour * 2 + i];
+ ivec2 pixelOffset = neighbourOffsets[neighbour];
+ ivec2 pixelUV = uv + pixelOffset;
+ vec3 msaaSample = texelFetch(sampler2DMS(srcTexture, MSAASampler), pixelUV, sampleIndex).rgb;
+ float d = distance(vec2(0.5), samplePositions[sampleIndex] + pixelOffset);
+ float w = reconstructionFilter(d);
+ color += tonemap(msaaSample) * w;
+ wTotal += w;
+ }
+ }
+ color /= wTotal;
+ color = tonemapReverse(color);
+
+ imageStore(outImage, uv, vec4(color, 0.f));
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/perMeshResources.inc b/projects/voxelization/resources/shaders/perMeshResources.inc
index 95e4fb7c27009965659d14a9c72acfec950c37e3..b1523713cf2040f672f74be3f47f9bf43996c614 100644
--- a/projects/voxelization/resources/shaders/perMeshResources.inc
+++ b/projects/voxelization/resources/shaders/perMeshResources.inc
@@ -1,2 +1,4 @@
layout(set=1, binding=0) uniform texture2D albedoTexture;
-layout(set=1, binding=1) uniform sampler textureSampler;
\ No newline at end of file
+layout(set=1, binding=1) uniform sampler textureSampler;
+layout(set=1, binding=2) uniform texture2D normalTexture;
+layout(set=1, binding=3) uniform texture2D specularTexture;
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/shader.frag b/projects/voxelization/resources/shaders/shader.frag
index 8653ae5958ce3b42eac6b1eaa6813f85b6ed589c..25ec69acb77bace1134920bbcee56deb40bb936b 100644
--- a/projects/voxelization/resources/shaders/shader.frag
+++ b/projects/voxelization/resources/shaders/shader.frag
@@ -5,10 +5,13 @@
#include "perMeshResources.inc"
#include "lightInfo.inc"
#include "shadowMapping.inc"
+#include "brdf.inc"
+#include "voxel.inc"
layout(location = 0) in vec3 passNormal;
layout(location = 1) in vec2 passUV;
layout(location = 2) in vec3 passPos;
+layout(location = 3) in vec4 passTangent;
layout(location = 0) out vec3 outColor;
@@ -18,11 +21,150 @@ layout(set=0, binding=0) uniform sunBuffer {
layout(set=0, binding=1) uniform texture2D shadowMap;
layout(set=0, binding=2) uniform sampler shadowMapSampler;
+layout(set=0, binding=3) uniform cameraBuffer {
+ vec3 cameraPos;
+};
+
+layout(set=0, binding=4) uniform texture3D voxelTexture;
+layout(set=0, binding=5) uniform sampler voxelSampler;
+
+layout(set=0, binding=6) uniform VoxelInfoBuffer{
+ VoxelInfo voxelInfo;
+};
+
+layout(set=0, binding=7) uniform VolumetricSettings {
+ vec3 scatteringCoefficient;
+ float volumetricAmbientLight;
+ vec3 absorptionCoefficient;
+};
+
+
+vec3 cookTorrance(vec3 f0, float r, vec3 N, vec3 V, vec3 L){
+
+ vec3 H = normalize(L + V);
+
+ float NoH = clamp(dot(N, H), 0, 1);
+ float NoL = clamp(dot(N, L), 0, 1);
+ float NoV = clamp(abs(dot(N, V)), 0, 1); // abs to account for wrong visibility caused by normal mapping
+
+ vec3 F = fresnelSchlick(NoH, f0);
+ float D = GGXDistribution(r, NoH);
+ float G = GGXSmithShadowing(r, NoV, NoL);
+
+ return (F * D * G) / max(4 * NoV * NoL, 0.00001);
+}
+
+float roughnessToConeAngleDegree(float r){
+ return mix(degreeToRadian(3), degreeToRadian(60), r);
+}
+
+// from: "Next Generation Post Processing in Call Of Duty Advanced Warfare" slide page 123
+float interleavedGradientNoise(vec2 uv){
+ vec3 magic = vec3(0.06711056, 0.00583715, 62.9829189);
+ return fract(magic.z * fract(dot(uv, magic.xy)));
+}
+
+// from: https://www.unrealengine.com/en-US/blog/physically-based-shading-on-mobile
+vec3 EnvBRDFApprox(vec3 SpecularColor, float Roughness, float NoV )
+{
+ const vec4 c0 = { -1, -0.0275, -0.572, 0.022 };
+ const vec4 c1 = { 1, 0.0425, 1.04, -0.04 };
+ vec4 r = Roughness * c0 + c1;
+ float a004 = min( r.x * r.x, exp2( -9.28 * NoV ) ) * r.x + r.y;
+ vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;
+ return SpecularColor * AB.x + AB.y;
+}
+
+float isotropicPhase(){
+ return 1 / (4 * pi);
+}
+
+vec3 volumetricLighting(vec3 colorIn, vec3 V, vec3 pos, float d){
+ vec3 color = colorIn;
+
+ int sampleCount = 20;
+ float stepSize = d / sampleCount;
+
+ vec3 extinctionCoefficient = scatteringCoefficient + absorptionCoefficient;
+
+ float noise = 2 * pi * interleavedGradientNoise(gl_FragCoord.xy);
+ vec2 shadowOffset = 3.f * vec2(sin(noise), cos(noise)) / textureSize(sampler2D(shadowMap, shadowMapSampler), 0);
+
+ float noiseScale = 0.1f;
+ pos += V * noiseScale * interleavedGradientNoise(gl_FragCoord.xy);
+
+ for(int i = 0; i < sampleCount; i++){
+ vec3 samplePoint = pos + V * i * stepSize;
+ float phase = isotropicPhase();
+ vec3 light = lightInfo.sunColor * lightInfo.sunStrength;
+ float shadow = shadowTest(samplePoint, lightInfo, shadowMap, shadowMapSampler, shadowOffset);
+ light *= shadow;
+ light += volumetricAmbientLight;
+
+ color += phase * light * scatteringCoefficient * stepSize;
+ color *= exp(-stepSize * extinctionCoefficient);
+ }
+ return color;
+}
+
void main() {
- vec3 N = normalize(passNormal);
- vec3 sun = lightInfo.sunStrength * lightInfo.sunColor * clamp(dot(N, lightInfo.L), 0, 1);
- sun *= shadowTest(passPos, lightInfo, shadowMap, shadowMapSampler);
- vec3 ambient = vec3(0.05);
- vec3 albedo = texture(sampler2D(albedoTexture, textureSampler), passUV).rgb;
- outColor = albedo * (sun + ambient);
+
+ vec3 albedoTexel = texture(sampler2D(albedoTexture, textureSampler), passUV).rgb;
+ vec3 normalTexel = texture(sampler2D(normalTexture, textureSampler), passUV).rgb;
+ vec3 specularTexel = texture(sampler2D(specularTexture, textureSampler), passUV).rgb;
+
+ float r = specularTexel.g;
+
+ float metal = specularTexel.b;
+ vec3 albedo = mix(albedoTexel, vec3(0), metal);
+ vec3 f0_dielectric = vec3(0.04f);
+ vec3 f0 = mix(f0_dielectric, albedoTexel, metal);
+
+ vec3 T = normalize(passTangent.xyz);
+ vec3 N_geo = normalize(passNormal);
+ vec3 B = cross(N_geo, T) * passTangent.w;
+ mat3 TBN = mat3(T, B, N_geo);
+ normalTexel = normalTexel * 2 - 1;
+
+ vec3 N = normalize(TBN * normalTexel);
+ vec3 L = lightInfo.L;
+ vec3 V = normalize(cameraPos - passPos);
+
+ float NoL = clamp(dot(N, L), 0, 1);
+ float NoV = clamp(abs(dot(N, V)), 0, 1);
+
+ vec3 sunSpecular = cookTorrance(f0, r, N, V, L);
+ vec3 sun = lightInfo.sunStrength * lightInfo.sunColor * NoL;
+
+ float noise = 2 * pi * interleavedGradientNoise(gl_FragCoord.xy);
+ vec2 shadowOffset = 0.05f * vec2(sin(noise), cos(noise)) / textureSize(sampler2D(shadowMap, shadowMapSampler), 0);
+ float shadow = shadowTest(passPos, lightInfo, shadowMap, shadowMapSampler, shadowOffset);
+ sun *= shadow;
+
+ vec3 F_in = fresnelSchlick(NoL, f0);
+ vec3 F_out = fresnelSchlick(NoV, f0);
+ vec3 diffuse = lambertBRDF(albedo) * (1 - F_in) * (1 - F_out);
+
+ vec3 up = abs(N_geo.y) >= 0.99 ? vec3(1, 0, 0) : vec3(0, 1, 0);
+ vec3 right = normalize(cross(up, N));
+ up = cross(N, right);
+ mat3 toSurface = mat3(right, up, N);
+
+ vec3 diffuseTrace = diffuseVoxelTraceHemisphere(toSurface, passPos, voxelTexture, voxelSampler, voxelInfo);
+
+ vec3 R = reflect(-V, N);
+ float reflectionConeAngle = roughnessToConeAngleDegree(r);
+ vec3 offsetTraceStart = passPos + N_geo * 0.1f;
+ offsetTraceStart += R * interleavedGradientNoise(gl_FragCoord.xy) * 0.5;
+ vec3 specularTrace = voxelConeTrace(R, offsetTraceStart, reflectionConeAngle, voxelTexture, voxelSampler, voxelInfo);
+ specularTrace *= clamp(dot(N, R), 0, 1);
+ vec3 reflectionBRDF = EnvBRDFApprox(f0, r, NoV);
+
+ outColor =
+ (diffuse + sunSpecular) * sun +
+ lambertBRDF(albedo) * diffuseTrace +
+ reflectionBRDF * specularTrace;
+
+ float d = distance(cameraPos, passPos);
+ outColor = volumetricLighting(outColor, V, passPos, d);
}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/shader.vert b/projects/voxelization/resources/shaders/shader.vert
index 926f86af2860cb57c44d2d5ee78712b6ae155e5c..e3873f98a308347592725e794d6b7102cbbe3e5c 100644
--- a/projects/voxelization/resources/shaders/shader.vert
+++ b/projects/voxelization/resources/shaders/shader.vert
@@ -4,10 +4,12 @@
layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inNormal;
layout(location = 2) in vec2 inUV;
+layout(location = 3) in vec4 inTangent;
layout(location = 0) out vec3 passNormal;
layout(location = 1) out vec2 passUV;
layout(location = 2) out vec3 passPos;
+layout(location = 3) out vec4 passTangent;
layout( push_constant ) uniform constants{
mat4 mvp;
@@ -19,4 +21,5 @@ void main() {
passNormal = mat3(model) * inNormal; // assuming no weird stuff like shearing or non-uniform scaling
passUV = inUV;
passPos = (model * vec4(inPosition, 1)).xyz;
+ passTangent = vec4(mat3(model) * inTangent.xyz, inTangent.w);
}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/shadow.frag b/projects/voxelization/resources/shaders/shadow.frag
index 848f853f556660b4900b5db7fb6fc98d57c1cd5b..65592d2cfe161b8522de1a0c3e68fa1d6afa80be 100644
--- a/projects/voxelization/resources/shaders/shadow.frag
+++ b/projects/voxelization/resources/shaders/shadow.frag
@@ -1,5 +1,6 @@
#version 450
#extension GL_ARB_separate_shader_objects : enable
+#extension GL_GOOGLE_include_directive : enable
void main() {
diff --git a/projects/voxelization/resources/shaders/shadow.vert b/projects/voxelization/resources/shaders/shadow.vert
index e0f41d42d575fa64fedbfa04adf89ac0f4aeebe8..d800c547368c4f2126c880534276a3be3cf336f5 100644
--- a/projects/voxelization/resources/shaders/shadow.vert
+++ b/projects/voxelization/resources/shaders/shadow.vert
@@ -1,6 +1,8 @@
#version 450
#extension GL_ARB_separate_shader_objects : enable
+#extension GL_GOOGLE_include_directive : enable
+
layout(location = 0) in vec3 inPosition;
layout( push_constant ) uniform constants{
diff --git a/projects/voxelization/resources/shaders/shadowBlur.inc b/projects/voxelization/resources/shaders/shadowBlur.inc
new file mode 100644
index 0000000000000000000000000000000000000000..06147415f118dca9badd15813b431a68682ce0b0
--- /dev/null
+++ b/projects/voxelization/resources/shaders/shadowBlur.inc
@@ -0,0 +1,27 @@
+#ifndef SHADOW_BLUR_INC
+#define SHADOW_BLUR_INC
+
+vec4 blurMomentShadowMap1D(ivec2 coord, ivec2 blurDirection, texture2D srcTexture, sampler depthSampler){
+
+ int blurRadius = 9;
+ int minOffset = -(blurRadius-1) / 2;
+ int maxOffset = -minOffset;
+
+ vec2 pixelSize = vec2(1) / textureSize(sampler2D(srcTexture, depthSampler), 0);
+
+ float wTotal = 0;
+ vec4 moments = vec4(0);
+
+ float weights1D[4] = { 0.5, 0.25, 0.125, 0.0625 }; // gaussian
+
+ for(int i = minOffset; i <= maxOffset; i++){
+ vec2 uv = (coord + i * blurDirection) * pixelSize;
+ uv += 0.5 * pixelSize * blurDirection * sign(i); // half pixel shift to take advantage of bilinear filtering
+ float w = weights1D[abs(i)];
+ moments += w * texture(sampler2D(srcTexture, depthSampler), uv);
+ wTotal += w;
+ }
+ return moments / wTotal;
+}
+
+#endif // #ifndef SHADOW_BLUR_INC
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/shadowBlurX.comp b/projects/voxelization/resources/shaders/shadowBlurX.comp
new file mode 100644
index 0000000000000000000000000000000000000000..45b91aad71673347dbf607fecef92463ef1c3c88
--- /dev/null
+++ b/projects/voxelization/resources/shaders/shadowBlurX.comp
@@ -0,0 +1,23 @@
+#version 450
+#extension GL_GOOGLE_include_directive : enable
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+#include "shadowBlur.inc"
+
+layout(set=0, binding=0) uniform texture2D srcTexture;
+layout(set=0, binding=1) uniform sampler depthSampler;
+layout(set=0, binding=2, rgba16) uniform image2D outImage;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+void main(){
+
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outImage)))){
+ return;
+ }
+ ivec2 coord = ivec2(gl_GlobalInvocationID.xy);
+ vec4 moments = blurMomentShadowMap1D(coord, ivec2(1, 0), srcTexture, depthSampler);
+
+ imageStore(outImage, coord, moments);
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/shadowBlurY.comp b/projects/voxelization/resources/shaders/shadowBlurY.comp
new file mode 100644
index 0000000000000000000000000000000000000000..51d4df054b0d99e54149863a5967143518f61dd2
--- /dev/null
+++ b/projects/voxelization/resources/shaders/shadowBlurY.comp
@@ -0,0 +1,25 @@
+#version 450
+#extension GL_GOOGLE_include_directive : enable
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+#include "shadowBlur.inc"
+
+layout(set=0, binding=0) uniform texture2D srcTexture;
+layout(set=0, binding=1) uniform sampler depthSampler;
+layout(set=0, binding=2, rgba16) uniform image2D outImage;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+void main(){
+
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outImage)))){
+ return;
+ }
+ ivec2 coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 pixelSize = vec2(1) / textureSize(sampler2D(srcTexture, depthSampler), 0);
+
+ vec4 moments = blurMomentShadowMap1D(coord, ivec2(0, 1), srcTexture, depthSampler);
+
+ imageStore(outImage, coord, moments);
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/shadowMapping.inc b/projects/voxelization/resources/shaders/shadowMapping.inc
index 1fa34a388c35b96a3316e972ca562d35e2c3cf90..c56ae8985c5c5fcef780b622d8b888f1081af74c 100644
--- a/projects/voxelization/resources/shaders/shadowMapping.inc
+++ b/projects/voxelization/resources/shaders/shadowMapping.inc
@@ -1,16 +1,95 @@
-float shadowTest(vec3 worldPos, LightInfo lightInfo, texture2D shadowMap, sampler shadowMapSampler){
- vec4 lightPos = lightInfo.lightMatrix * vec4(worldPos, 1);
- lightPos /= lightPos.w;
- lightPos.xy = lightPos.xy * 0.5 + 0.5;
+#ifndef SHADOW_MAPPING_INC
+#define SHADOW_MAPPING_INC
+
+#include "lightInfo.inc"
+
+// nice math blob from the moment shadow mapping presentation
+float ComputeMSMShadowIntensity(vec4 _4Moments, float FragmentDepth, float DepthBias, float MomentBias)
+{
+ vec4 b=mix(_4Moments, vec4(0.5),MomentBias);
+ vec3 z;
+ z[0]=FragmentDepth-DepthBias;
+ float L32D22=fma(-b[0], b[1], b[2]);
+ float D22=fma(-b[0], b[0], b[1]);
+ float SquaredDepthVariance=fma(-b[1], b[1], b[3]);
+ float D33D22=dot(vec2(SquaredDepthVariance,-L32D22),
+ vec2(D22, L32D22));
+
+ float InvD22=1.0/D22;
+ float L32=L32D22*InvD22;
+ vec3 c=vec3(1.0,z[0],z[0]*z[0]);
+ c[1]-=b.x;
+ c[2]-=b.y+L32*c[1];
+ c[1]*=InvD22;
+ c[2]*=D22/D33D22;
+ c[1]-=L32*c[2];
+ c[0]-=dot(c.yz,b.xy);
+ float p=c[1]/c[2];
+ float q=c[0]/c[2];
+ float r=sqrt((p*p*0.25)-q);
+ z[1]=-p*0.5-r;
+ z[2]=-p*0.5+r;
+ vec4 Switch=
+ (z[2]<z[0])?vec4(z[1],z[0],1.0,1.0):(
+ (z[1]<z[0])?vec4(z[0],z[1],0.0,1.0):
+ vec4(0.0));
+ float Quotient=(Switch[0]*z[2]-b[0]*(Switch[0]+z[2])+b[1])
+ /((z[2]-Switch[1])*(z[0]-z[1]));
+ return 1-clamp(Switch[2]+Switch[3]*Quotient, 0, 1);
+}
+
+vec4 quantizeMoments(vec4 moments){
+ mat4 T = mat4(
+ -2.07224649, 13.7948857237, 0.105877704, 9.7924062118,
+ 32.23703778, -59.4683975703, -1.9077466311, -33.7652110555,
+ -68.571074599, 82.0359750338, 9.3496555107, 47.9456096605,
+ 39.3703274134, -35.364903257, -6.6543490743, -23.9728048165);
+ vec4 quantized = T * moments;
+ quantized[0] += 0.0359558848;
+ return quantized;
+}
+
+vec4 unquantizeMoments(vec4 moments){
+ moments[0] -= 0.0359558848;
+ mat4 T = mat4(
+ 0.2227744146, 0.1549679261, 0.1451988946, 0.163127443,
+ 0.0771972861, 0.1394629426, 0.2120202157, 0.2591432266,
+ 0.7926986636, 0.7963415838, 0.7258694464, 0.6539092497,
+ 0.0319417555, -0.1722823173, -0.2758014811, -0.3376131734);
+ return T * moments;
+}
+
+float rescaleRange(float a, float b, float v)
+{
+ return clamp((v - a) / (b - a), 0, 1);
+}
+
+float reduceLightBleeding(float shadow, float amount)
+{
+ return rescaleRange(amount, 1.0f, shadow);
+}
+
+float shadowTest(vec3 worldPos, LightInfo lightInfo, texture2D shadowMap, sampler shadowMapSampler, vec2 offset){
+ vec4 lightPos = lightInfo.lightMatrix * vec4(worldPos, 1);
+ lightPos /= lightPos.w;
+ lightPos.xy = lightPos.xy * 0.5 + 0.5;
+ lightPos.xy += offset;
if(any(lessThan(lightPos.xy, vec2(0))) || any(greaterThan(lightPos.xy, vec2(1)))){
return 1;
}
lightPos.z = clamp(lightPos.z, 0, 1);
+
+ vec4 shadowMapSample = texture(sampler2D(shadowMap, shadowMapSampler), lightPos.xy);
- float shadowMapSample = texture(sampler2D(shadowMap, shadowMapSampler), lightPos.xy).r;
- float bias = 0.01f;
- shadowMapSample += bias;
- return shadowMapSample < lightPos.z ? 0 : 1;
-}
\ No newline at end of file
+ shadowMapSample = unquantizeMoments(shadowMapSample);
+
+ float depthBias = 0.f;
+ float momentBias = 0.0003;
+
+ float shadow = ComputeMSMShadowIntensity(shadowMapSample, lightPos.z, depthBias, momentBias);
+ return reduceLightBleeding(shadow, 0.1f);
+}
+
+#endif // #ifndef SHADOW_MAPPING_INC
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/sky.frag b/projects/voxelization/resources/shaders/sky.frag
new file mode 100644
index 0000000000000000000000000000000000000000..2a3b2ad03e1936641a565b2f3fbd1f19f186ff7a
--- /dev/null
+++ b/projects/voxelization/resources/shaders/sky.frag
@@ -0,0 +1,13 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) out vec3 outColor;
+
+layout( push_constant ) uniform constants{
+ vec3 skyColor;
+ float skyStrength;
+};
+
+void main() {
+ outColor = skyColor * skyStrength;
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/sky.vert b/projects/voxelization/resources/shaders/sky.vert
new file mode 100644
index 0000000000000000000000000000000000000000..686e6f352e9bb1054656f58340a9cfc9b55fcff4
--- /dev/null
+++ b/projects/voxelization/resources/shaders/sky.vert
@@ -0,0 +1,12 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+const vec2 positions[3] = {
+ vec2(-1, -1),
+ vec2(-1, 4),
+ vec2(4, -1)
+};
+
+void main() {
+ gl_Position = vec4(positions[gl_VertexIndex], 1, 1);
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/tonemapping.comp b/projects/voxelization/resources/shaders/tonemapping.comp
index 2383302fa946e7d92871039daff28232df2eafdd..8fa07d39ebb56eab857cdccb755a6558f5ae1ec3 100644
--- a/projects/voxelization/resources/shaders/tonemapping.comp
+++ b/projects/voxelization/resources/shaders/tonemapping.comp
@@ -1,19 +1,149 @@
#version 440
+#extension GL_GOOGLE_include_directive : enable
-layout(set=0, binding=0, r11f_g11f_b10f) uniform image2D inImage;
-layout(set=0, binding=1, rgba8) uniform image2D outImage;
+#include "luma.inc"
+layout(set=0, binding=0) uniform texture2D inTexture;
+layout(set=0, binding=1) uniform sampler textureSampler;
+layout(set=0, binding=2, rgba8) uniform image2D outImage;
layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+layout( push_constant ) uniform constants{
+ float time;
+};
+
+// from: https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/
+vec3 ACESFilm(vec3 x)
+{
+ float a = 2.51f;
+ float b = 0.03f;
+ float c = 2.43f;
+ float d = 0.59f;
+ float e = 0.14f;
+ return clamp((x*(a*x+b))/(x*(c*x+d)+e), 0, 1);
+}
+
+// From Dave Hoskins: https://www.shadertoy.com/view/4djSRW.
+float hash(vec3 p3){
+ p3 = fract(p3 * 0.1031);
+ p3 += dot(p3,p3.yzx + 19.19);
+ return fract((p3.x + p3.y) * p3.z);
+}
+
+// From iq: https://www.shadertoy.com/view/4sfGzS.
+float noise(vec3 x){
+ vec3 i = floor(x);
+ vec3 f = fract(x);
+ f = f*f*(3.0-2.0*f);
+ return mix(mix(mix(hash(i+vec3(0, 0, 0)),
+ hash(i+vec3(1, 0, 0)),f.x),
+ mix(hash(i+vec3(0, 1, 0)),
+ hash(i+vec3(1, 1, 0)),f.x),f.y),
+ mix(mix(hash(i+vec3(0, 0, 1)),
+ hash(i+vec3(1, 0, 1)),f.x),
+ mix(hash(i+vec3(0, 1, 1)),
+ hash(i+vec3(1, 1, 1)),f.x),f.y),f.z);
+}
+
+// From: https://www.shadertoy.com/view/3sGSWVF
+// Slightly high-passed continuous value-noise.
+float grainSource(vec3 x, float strength, float pitch){
+ float center = noise(x);
+ float v1 = center - noise(vec3( 1, 0, 0)/pitch + x) + 0.5;
+ float v2 = center - noise(vec3( 0, 1, 0)/pitch + x) + 0.5;
+ float v3 = center - noise(vec3(-1, 0, 0)/pitch + x) + 0.5;
+ float v4 = center - noise(vec3( 0,-1, 0)/pitch + x) + 0.5;
+
+ float total = (v1 + v2 + v3 + v4) / 4.0;
+ return mix(1, 0.5 + total, strength);
+}
+
+vec3 applyGrain(ivec2 uv, vec3 c){
+ float grainLift = 0.6;
+ float grainStrength = 0.4;
+ float grainTimeFactor = 0.1;
+
+ float timeColorOffset = 1.2;
+ vec3 grain = vec3(
+ grainSource(vec3(uv, floor(grainTimeFactor*time)), grainStrength, grainLift),
+ grainSource(vec3(uv, floor(grainTimeFactor*time + timeColorOffset)), grainStrength, grainLift),
+ grainSource(vec3(uv, floor(grainTimeFactor*time - timeColorOffset)), grainStrength, grainLift));
+
+ return c * grain;
+}
+
+vec2 computeDistortedUV(vec2 uv, float aspectRatio){
+ uv = uv * 2 - 1;
+ float r2 = dot(uv, uv);
+ float k1 = 0.02f;
+
+ float maxR2 = dot(vec2(1), vec2(1));
+ float maxFactor = maxR2 * k1;
+
+ // correction only needed for pincushion distortion
+ maxFactor = min(maxFactor, 0);
+
+ uv /= 1 + r2*k1;
+
+ // correction to avoid going out of [-1, 1] range when using barrel distortion
+ uv *= 1 + maxFactor;
+
+ return uv * 0.5 + 0.5;
+}
+
+float computeLocalContrast(vec2 uv){
+ float lumaMin = 100;
+ float lumaMax = 0;
+
+ vec2 pixelSize = vec2(1) / textureSize(sampler2D(inTexture, textureSampler), 0);
+
+ for(int x = -1; x <= 1; x++){
+ for(int y = -1; y <= 1; y++){
+ vec3 c = texture(sampler2D(inTexture, textureSampler), uv + vec2(x, y) * pixelSize).rgb;
+ float luma = computeLuma(c);
+ lumaMin = min(lumaMin, luma);
+ lumaMax = max(lumaMax, luma);
+ }
+ }
+
+ return lumaMax - lumaMin;
+}
+
+vec3 computeChromaticAberrationScale(vec2 uv){
+ float localContrast = computeLocalContrast(uv);
+ vec3 colorScales = vec3(-1, 0, 1);
+ float aberrationScale = 0.004;
+ vec3 maxScaleFactors = colorScales * aberrationScale;
+ float factor = clamp(localContrast, 0, 1);
+ return mix(vec3(0), maxScaleFactors, factor);
+}
+
+vec3 sampleColorChromaticAberration(vec2 uv){
+ vec2 toCenter = (vec2(0.5) - uv);
+
+ vec3 scaleFactors = computeChromaticAberrationScale(uv);
+
+ float r = texture(sampler2D(inTexture, textureSampler), uv + toCenter * scaleFactors.r).r;
+ float g = texture(sampler2D(inTexture, textureSampler), uv + toCenter * scaleFactors.g).g;
+ float b = texture(sampler2D(inTexture, textureSampler), uv + toCenter * scaleFactors.b).b;
+ return vec3(r, g, b);
+}
+
void main(){
- if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(inImage)))){
+ if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outImage)))){
return;
}
- ivec2 uv = ivec2(gl_GlobalInvocationID.xy);
- vec3 linearColor = imageLoad(inImage, uv).rgb;
- vec3 tonemapped = linearColor / (linearColor + 1); // reinhard tonemapping
+ ivec2 textureRes = textureSize(sampler2D(inTexture, textureSampler), 0);
+ ivec2 coord = ivec2(gl_GlobalInvocationID.xy);
+ vec2 uv = vec2(coord) / textureRes;
+ float aspectRatio = float(textureRes.x) / textureRes.y;
+ uv = computeDistortedUV(uv, aspectRatio);
+ vec3 linearColor = sampleColorChromaticAberration(uv);
+ vec3 tonemapped = ACESFilm(linearColor);
+ tonemapped = applyGrain(coord, tonemapped);
+
vec3 gammaCorrected = pow(tonemapped, vec3(1.f / 2.2f));
- imageStore(outImage, uv, vec4(gammaCorrected, 0.f));
+ imageStore(outImage, coord, vec4(gammaCorrected, 0.f));
}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/voxel.inc b/projects/voxelization/resources/shaders/voxel.inc
index 25c0a82bbc887913a4d69ccdeee2b0d8934828c8..6133ca7cfc52ca77cb70fb8c2cc0e83ef6da4016 100644
--- a/projects/voxelization/resources/shaders/voxel.inc
+++ b/projects/voxelization/resources/shaders/voxel.inc
@@ -1,12 +1,32 @@
+#include "brdf.inc"
+
struct VoxelInfo{
vec3 offset;
float extent;
};
+struct PackedVoxelData{
+ uint color;
+ uint normal;
+ uint albedo;
+};
+
uint flattenVoxelUVToIndex(ivec3 UV, ivec3 voxelImageSize){
return UV.x + UV.y * voxelImageSize.x + UV.z * voxelImageSize.x* voxelImageSize.y;
}
+vec3 worldToVoxelCoordinates(vec3 world, VoxelInfo info){
+ return (world - info.offset) / info.extent + 0.5f;
+}
+
+ivec3 voxelCoordinatesToUV(vec3 voxelCoordinates, ivec3 voxelImageResolution){
+ return ivec3(voxelCoordinates * voxelImageResolution);
+}
+
+vec3 voxelCoordinatesToWorldPosition(ivec3 coord, int voxelResolution, VoxelInfo voxelInfo, float voxelHalfSize){
+ return (vec3(coord) / voxelResolution - 0.5) * voxelInfo.extent + voxelHalfSize + voxelInfo.offset;
+}
+
// packed voxel data:
// 1 bit opacity
// 7 bit exposure
@@ -15,7 +35,7 @@ uint flattenVoxelUVToIndex(ivec3 UV, ivec3 voxelImageSize){
// 8 bit red
float maxExposure = 16.f;
-uint packVoxelInfo(vec3 color){
+uint packVoxelColor(vec3 color){
color = clamp(color, vec3(0), vec3(maxExposure));
float maxComponent = max(max(max(color.r, color.g), color.b), 1.f);
@@ -29,7 +49,7 @@ uint packVoxelInfo(vec3 color){
return opaqueBit | exposureBits | blueBits | greenBits | redBits;
}
-vec4 unpackVoxelInfo(uint packed){
+vec4 unpackVoxelColor(uint packed){
vec4 rgba;
rgba.r = (packed >> 0 & 0x000000FF) / 255.f;
rgba.g = (packed >> 8 & 0x000000FF) / 255.f;
@@ -39,4 +59,121 @@ vec4 unpackVoxelInfo(uint packed){
rgba.rgb *= (packed >> 24 & 0x0000007F) / 127.f * maxExposure;
return rgba;
+}
+
+uint packSNormInto9Bits(float x){
+ uint lengthBits = 0x000000FF & uint(abs(x) * 255.f);
+ uint signBits = (x < 0 ? 1 : 0) << 8;
+ return lengthBits | signBits;
+}
+
+float unpack9LowBitsIntoSNorm(uint bits){
+ bits = (0x000001FF & bits);
+ float length = bits / 255.f;
+ float sign = (bits >> 8) == 0 ? 1 : -1;
+ return sign * length;
+}
+
+// normals are packed with 9 bits each, 8 for length and 1 for sign
+uint packVoxelNormal(vec3 N){
+ N = clamp(N, vec3(0), vec3(1));
+ uint xBits = packSNormInto9Bits(N.x) << 0;
+ uint yBits = packSNormInto9Bits(N.y) << 9;
+ uint zBits = packSNormInto9Bits(N.z) << 18;
+ return zBits | yBits | xBits;
+}
+
+vec3 unpackVoxelNormal(uint packed){
+ vec3 N;
+ N.x = unpack9LowBitsIntoSNorm(packed >> 0);
+ N.y = unpack9LowBitsIntoSNorm(packed >> 9);
+ N.z = unpack9LowBitsIntoSNorm(packed >> 18);
+ return normalize(N);
+}
+
+uint packUNormInto8Bits(float x){
+ return 0x000000FF & uint(abs(x) * 255.f);
+}
+
+float unpack8LowBitsIntoUNorm(uint bits){
+ bits = (0x000000FF & bits);
+ return bits / 255.f;
+}
+
+// albedo is packed with 8 bits each
+uint packVoxelAlbedo(vec3 albedo){
+ albedo = clamp(albedo, vec3(0), vec3(1));
+ uint rBits = packUNormInto8Bits(albedo.r) << 0;
+ uint gBits = packUNormInto8Bits(albedo.g) << 8;
+ uint bBits = packUNormInto8Bits(albedo.b) << 16;
+ return bBits | gBits | rBits;
+}
+
+vec3 unpackVoxelAlbedo(uint packed){
+ vec3 albedo;
+ albedo.r = unpack8LowBitsIntoUNorm(packed >> 0);
+ albedo.g = unpack8LowBitsIntoUNorm(packed >> 8);
+ albedo.b = unpack8LowBitsIntoUNorm(packed >> 16);
+ return albedo;
+}
+
+vec3 voxelConeTrace(vec3 direction, vec3 startPosition, float coneAngleRadian, texture3D voxelTexture, sampler voxelSampler, VoxelInfo voxelInfo){
+
+ int voxelResolution = textureSize(sampler3D(voxelTexture, voxelSampler), 0).x;
+ float voxelSize = voxelInfo.extent / voxelResolution;
+ float maxMip = float(log2(voxelResolution));
+ float maxStableMip = 4; // must be the same as in Voxelization::voxelizeMeshes
+ maxMip = min(maxMip, maxStableMip);
+ float d = 2 * sqrt(3 * pow(voxelSize, 2));
+ vec3 color = vec3(0);
+ float a = 0;
+
+ float coneAngleHalf = coneAngleRadian * 0.5f;
+
+ int maxSamples = 16;
+ for(int i = 0; i < maxSamples; i++){
+
+ vec3 samplePos = startPosition + d * direction;
+ vec3 sampleUV = worldToVoxelCoordinates(samplePos, voxelInfo);
+
+ if(a >= 0.95 || any(lessThan(sampleUV, vec3(0))) || any(greaterThan(sampleUV, vec3(1)))){
+ break;
+ }
+
+ float coneDiameter = 2 * tan(coneAngleHalf) * d;
+ float mip = log2(coneDiameter / voxelSize);
+ mip = min(mip, maxMip);
+
+ vec4 voxelSample = textureLod(sampler3D(voxelTexture, voxelSampler), sampleUV , mip);
+
+ color += (1 - a) * voxelSample.rgb;
+ a += (1 - a) * voxelSample.a;
+
+ float minStepSize = 1.f;
+ d += max(coneDiameter, minStepSize);
+ }
+ return color;
+}
+
+float degreeToRadian(float d){
+ return d / 180.f * pi;
+}
+
+vec3 diffuseVoxelTraceHemisphere(mat3 toSurface, vec3 position, texture3D voxelTexture, sampler voxelSampler, VoxelInfo voxelInfo){
+ float coneAngle = degreeToRadian(60.f);
+ vec3 diffuseTrace = vec3(0);
+ {
+ vec3 sampleDirection = toSurface * vec3(0, 0, 1);
+ float weight = pi / 4.f;
+ diffuseTrace += weight * voxelConeTrace(sampleDirection, position, coneAngle, voxelTexture, voxelSampler, voxelInfo);
+ }
+ for(int i = 0; i < 6;i++){
+ float theta = 2 * pi / i;
+ float phi = pi / 3; // 60 degrees
+ vec3 sampleDirection = toSurface * vec3(cos(theta) * sin(phi), sin(theta) * sin(phi), cos(phi));
+ float weight = pi * (3.f / 4.f) / 6;
+ vec3 trace = voxelConeTrace(sampleDirection, position, coneAngle, voxelTexture, voxelSampler, voxelInfo);
+ diffuseTrace += weight * trace;
+ }
+ return diffuseTrace;
}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/voxelBufferToImage.comp b/projects/voxelization/resources/shaders/voxelBufferToImage.comp
index 5e8298886cb2bacbc81f981e8e90310cdc876d5d..2c2cffe856c8b0fc7db07202572aaa35e8445603 100644
--- a/projects/voxelization/resources/shaders/voxelBufferToImage.comp
+++ b/projects/voxelization/resources/shaders/voxelBufferToImage.comp
@@ -3,7 +3,7 @@
#include "voxel.inc"
layout(set=0, binding=0, std430) buffer voxelBuffer{
- uint packedVoxelData[];
+ PackedVoxelData packedVoxelData[];
};
layout(set=0, binding=1, rgba16f) uniform image3D voxelImage;
@@ -19,6 +19,15 @@ void main(){
ivec3 UV = ivec3(gl_GlobalInvocationID);
uint flatIndex = flattenVoxelUVToIndex(UV, voxelImageSize);
- vec4 color = unpackVoxelInfo(packedVoxelData[flatIndex]);
+ vec4 color = unpackVoxelColor(packedVoxelData[flatIndex].color);
+
+ // for proper visualisation voxel secondary bounce should be disabled, otherwise it adds color
+
+ // for debugging: write normal into image, so voxel visualisation draws normal
+ // color = vec4(unpackVoxelNormal(packedVoxelData[flatIndex].normal), color.a);
+
+ // for debugging: write albedo into image, so voxel visualisation draws albedo
+ // color = vec4(unpackVoxelAlbedo(packedVoxelData[flatIndex].albedo), color.a);
+
imageStore(voxelImage, UV, vec4(color));
}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/voxelReset.comp b/projects/voxelization/resources/shaders/voxelReset.comp
index 14b78d6584d703be68594e3cb03ebcd47c94b6e0..79eda9ec95e703d39af57bc3b29044f0ad6c1bf9 100644
--- a/projects/voxelization/resources/shaders/voxelReset.comp
+++ b/projects/voxelization/resources/shaders/voxelReset.comp
@@ -1,7 +1,9 @@
#version 450
+#extension GL_GOOGLE_include_directive : enable
+#include "voxel.inc"
layout(set=0, binding=0) buffer voxelizationBuffer{
- uint isFilled[];
+ PackedVoxelData packedVoxelData[];
};
layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
@@ -15,5 +17,7 @@ void main(){
if(gl_GlobalInvocationID.x> voxelCount){
return;
}
- isFilled[gl_GlobalInvocationID.x] = 0;
+ packedVoxelData[gl_GlobalInvocationID.x].color = 0;
+ packedVoxelData[gl_GlobalInvocationID.x].normal = 0;
+ packedVoxelData[gl_GlobalInvocationID.x].albedo = 0;
}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/voxelSecondaryBounce.comp b/projects/voxelization/resources/shaders/voxelSecondaryBounce.comp
new file mode 100644
index 0000000000000000000000000000000000000000..29026e7052861ab190200b23d9f860bc609d1550
--- /dev/null
+++ b/projects/voxelization/resources/shaders/voxelSecondaryBounce.comp
@@ -0,0 +1,46 @@
+#version 450
+#extension GL_GOOGLE_include_directive : enable
+#include "voxel.inc"
+#include "brdf.inc"
+
+layout(set=0, binding=0, std430) buffer voxelBuffer{
+ PackedVoxelData packedVoxelData[];
+};
+layout(set=0, binding=1) uniform texture3D voxelImageIn;
+layout(set=0, binding=2) uniform sampler voxelSampler;
+layout(set=0, binding=3, rgba16f) uniform image3D voxelImageOut;
+layout(set=0, binding=4) uniform voxelizationInfo{
+ VoxelInfo voxelInfo;
+};
+
+layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;
+
+void main(){
+
+ ivec3 voxelImageSize = imageSize(voxelImageOut);
+ if(any(greaterThanEqual(gl_GlobalInvocationID, voxelImageSize))){
+ return;
+ }
+ ivec3 UV = ivec3(gl_GlobalInvocationID);
+
+ vec4 color = texelFetch(sampler3D(voxelImageIn, voxelSampler), UV, 0);
+
+ if(color.a > 0){
+ uint flatIndex = flattenVoxelUVToIndex(UV, voxelImageSize);
+ vec3 N = unpackVoxelNormal(packedVoxelData[flatIndex].normal);
+
+ float halfVoxelSize = voxelInfo.extent / float(voxelImageSize.x) * 0.5f;
+ vec3 pos = voxelCoordinatesToWorldPosition(UV, voxelImageSize.x, voxelInfo, halfVoxelSize);
+
+ vec3 up = abs(N.y) >= 0.99 ? vec3(1, 0, 0) : vec3(0, 1, 0);
+ vec3 right = normalize(cross(up, N));
+ up = cross(N, right);
+ mat3 toSurface = mat3(right, up, N);
+
+ vec3 secondaryBounce = diffuseVoxelTraceHemisphere(toSurface, pos, voxelImageIn, voxelSampler, voxelInfo);
+ vec3 albedo = unpackVoxelAlbedo(packedVoxelData[flatIndex].albedo);
+ color.rgb += lambertBRDF(albedo) * secondaryBounce;
+ }
+
+ imageStore(voxelImageOut, UV, color);
+}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/voxelVisualisation.vert b/projects/voxelization/resources/shaders/voxelVisualisation.vert
index 8377143f4f4bbf351d3251df9724d37e1747a4dc..e26e2209ffb9bd3e62103fa9e7eeccce13d7d602 100644
--- a/projects/voxelization/resources/shaders/voxelVisualisation.vert
+++ b/projects/voxelization/resources/shaders/voxelVisualisation.vert
@@ -25,7 +25,7 @@ void main() {
int index2D = gl_VertexIndex % slicePixelCount;
int y = index2D / voxelResolution;
int x = index2D % voxelResolution;
- vec3 position = (vec3(x, y, z) / voxelResolution - 0.5) * voxelInfo.extent + passCubeHalf + voxelInfo.offset;
+ vec3 position = voxelCoordinatesToWorldPosition(ivec3(x, y, z), voxelResolution, voxelInfo, passCubeHalf);
gl_Position = vec4(position, 1.0);
vec4 voxelColor = imageLoad(voxelImage, ivec3(x,y,z));
diff --git a/projects/voxelization/resources/shaders/voxelization.frag b/projects/voxelization/resources/shaders/voxelization.frag
index a49b13185ec26b069661141cfdbbfbbe45d14fd3..0bbd26bff249db1390399b26f2f4b5a139195fef 100644
--- a/projects/voxelization/resources/shaders/voxelization.frag
+++ b/projects/voxelization/resources/shaders/voxelization.frag
@@ -6,13 +6,14 @@
#include "perMeshResources.inc"
#include "lightInfo.inc"
#include "shadowMapping.inc"
+#include "brdf.inc"
layout(location = 0) in vec3 passPos;
layout(location = 1) in vec2 passUV;
layout(location = 2) in vec3 passN;
layout(set=0, binding=0, std430) buffer voxelizationBuffer{
- uint packedVoxelData[];
+ PackedVoxelData packedVoxelData[];
};
layout(set=0, binding=1) uniform voxelizationInfo{
@@ -28,14 +29,6 @@ layout(set=0, binding=3) uniform sunBuffer {
layout(set=0, binding=4) uniform texture2D shadowMap;
layout(set=0, binding=5) uniform sampler shadowMapSampler;
-vec3 worldToVoxelCoordinates(vec3 world, VoxelInfo info){
- return (world - info.offset) / info.extent + 0.5f;
-}
-
-ivec3 voxelCoordinatesToUV(vec3 voxelCoordinates, ivec3 voxelImageResolution){
- return ivec3(voxelCoordinates * voxelImageResolution);
-}
-
void main() {
vec3 voxelCoordinates = worldToVoxelCoordinates(passPos, voxelInfo);
ivec3 voxelImageSize = imageSize(voxelImage);
@@ -49,9 +42,11 @@ void main() {
vec3 N = normalize(passN);
float NoL = clamp(dot(N, lightInfo.L), 0, 1);
- vec3 sun = lightInfo.sunStrength * lightInfo.sunColor * NoL * shadowTest(passPos, lightInfo, shadowMap, shadowMapSampler);
+ vec3 sun = lightInfo.sunStrength * lightInfo.sunColor * NoL * shadowTest(passPos, lightInfo, shadowMap, shadowMapSampler, vec2(0));
vec3 color = albedo * sun;
- color = albedo * sun;
+ color = lambertBRDF(albedo) * sun;
- atomicMax(packedVoxelData[flatIndex], packVoxelInfo(color));
+ atomicMax(packedVoxelData[flatIndex].color, packVoxelColor(color));
+ atomicMax(packedVoxelData[flatIndex].normal, packVoxelNormal(N));
+ atomicMax(packedVoxelData[flatIndex].albedo, packVoxelAlbedo(albedo));
}
\ No newline at end of file
diff --git a/projects/voxelization/resources/shaders/voxelization.vert b/projects/voxelization/resources/shaders/voxelization.vert
index 1302a42441b5b9c8ea7d24f97d29b684e4d64993..221d0f6d189cfe1d6fb8e9e8e2fc9c04884c40c1 100644
--- a/projects/voxelization/resources/shaders/voxelization.vert
+++ b/projects/voxelization/resources/shaders/voxelization.vert
@@ -18,5 +18,5 @@ void main() {
gl_Position = mvp * vec4(inPosition, 1.0);
passPos = (model * vec4(inPosition, 1)).xyz;
passUV = inUV;
- passN = inNormal;
+ passN = mat3(model) * inNormal;
}
\ No newline at end of file
diff --git a/projects/voxelization/src/BloomAndFlares.cpp b/projects/voxelization/src/BloomAndFlares.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fac57735a6544c197f880f78e1f512382607d048
--- /dev/null
+++ b/projects/voxelization/src/BloomAndFlares.cpp
@@ -0,0 +1,341 @@
+#include "BloomAndFlares.hpp"
+#include <vkcv/shader/GLSLCompiler.hpp>
+#include <vkcv/asset/asset_loader.hpp>
+
+vkcv::Image loadLenseDirtTexture(vkcv::Core* corePtr) {
+ const auto texture = vkcv::asset::loadTexture("resources/lensDirt.jpg");
+ vkcv::Image image = corePtr->createImage(vk::Format::eR8G8B8A8Unorm, texture.width, texture.height);
+ image.fill((void*)texture.data.data(), texture.data.size());
+ return image;
+}
+
+BloomAndFlares::BloomAndFlares(
+ vkcv::Core *p_Core,
+ vk::Format colorBufferFormat,
+ uint32_t width,
+ uint32_t height) :
+
+ p_Core(p_Core),
+ m_ColorBufferFormat(colorBufferFormat),
+ m_Width(width / 2),
+ m_Height(height / 2),
+ m_LinearSampler(p_Core->createSampler(vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::CLAMP_TO_EDGE)),
+ m_RadialLutSampler(p_Core->createSampler(vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::REPEAT)),
+ m_Blur(p_Core->createImage(colorBufferFormat, m_Width, m_Height, 1, true, true, false)),
+ m_LensFeatures(p_Core->createImage(colorBufferFormat, m_Width, m_Height, 1, true, true, false)),
+ m_radialLut(p_Core->createImage(vk::Format::eR8G8B8A8Unorm, 128, 10, 1)),
+ m_lensDirt(loadLenseDirtTexture(p_Core))
+{
+ vkcv::shader::GLSLCompiler compiler;
+
+ // DOWNSAMPLE
+ vkcv::ShaderProgram dsProg;
+ compiler.compile(vkcv::ShaderStage::COMPUTE,
+ "resources/shaders/bloomDownsample.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
+ {
+ dsProg.addShader(shaderStage, path);
+ });
+ for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
+ {
+ m_DownsampleDescSets.push_back(
+ p_Core->createDescriptorSet(dsProg.getReflectedDescriptors()[0]));
+ }
+ m_DownsamplePipe = p_Core->createComputePipeline(
+ dsProg, { p_Core->getDescriptorSet(m_DownsampleDescSets[0]).layout });
+
+ // UPSAMPLE
+ vkcv::ShaderProgram usProg;
+ compiler.compile(vkcv::ShaderStage::COMPUTE,
+ "resources/shaders/bloomUpsample.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
+ {
+ usProg.addShader(shaderStage, path);
+ });
+ for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
+ {
+ m_UpsampleDescSets.push_back(
+ p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
+ }
+ for (uint32_t mipLevel = 0; mipLevel < m_LensFeatures.getMipCount(); mipLevel++) {
+ m_UpsampleLensFlareDescSets.push_back(
+ p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
+ }
+
+ m_UpsamplePipe = p_Core->createComputePipeline(
+ usProg, { p_Core->getDescriptorSet(m_UpsampleDescSets[0]).layout });
+
+ // LENS FEATURES
+ vkcv::ShaderProgram lensProg;
+ compiler.compile(vkcv::ShaderStage::COMPUTE,
+ "resources/shaders/lensFlares.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
+ {
+ lensProg.addShader(shaderStage, path);
+ });
+ m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors()[0]);
+ m_LensFlarePipe = p_Core->createComputePipeline(
+ lensProg, { p_Core->getDescriptorSet(m_LensFlareDescSet).layout });
+
+ // COMPOSITE
+ vkcv::ShaderProgram compProg;
+ compiler.compile(vkcv::ShaderStage::COMPUTE,
+ "resources/shaders/bloomFlaresComposite.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
+ {
+ compProg.addShader(shaderStage, path);
+ });
+ m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors()[0]);
+ m_CompositePipe = p_Core->createComputePipeline(
+ compProg, { p_Core->getDescriptorSet(m_CompositeDescSet).layout });
+
+ // radial LUT
+ const auto texture = vkcv::asset::loadTexture("resources/RadialLUT.png");
+
+ m_radialLut.fill((void*)texture.data.data(), texture.data.size());
+}
+
+void BloomAndFlares::execDownsamplePipe(const vkcv::CommandStreamHandle &cmdStream,
+ const vkcv::ImageHandle &colorAttachment)
+{
+ auto dispatchCountX = static_cast<float>(m_Width) / 8.0f;
+ auto dispatchCountY = static_cast<float>(m_Height) / 8.0f;
+ // blur dispatch
+ uint32_t initialDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(dispatchCountX)),
+ static_cast<uint32_t>(glm::ceil(dispatchCountY)),
+ 1
+ };
+
+ // downsample dispatch of original color attachment
+ p_Core->prepareImageForSampling(cmdStream, colorAttachment);
+ p_Core->prepareImageForStorage(cmdStream, m_Blur.getHandle());
+
+ vkcv::DescriptorWrites initialDownsampleWrites;
+ initialDownsampleWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, colorAttachment)};
+ initialDownsampleWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(1, m_LinearSampler)};
+ initialDownsampleWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(2, m_Blur.getHandle(), 0) };
+ p_Core->writeDescriptorSet(m_DownsampleDescSets[0], initialDownsampleWrites);
+
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_DownsamplePipe,
+ initialDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_DownsampleDescSets[0]).vulkanHandle)},
+ vkcv::PushConstantData(nullptr, 0));
+
+ // downsample dispatches of blur buffer's mip maps
+ float mipDispatchCountX = dispatchCountX;
+ float mipDispatchCountY = dispatchCountY;
+ for(uint32_t mipLevel = 1; mipLevel < std::min((uint32_t)m_DownsampleDescSets.size(), m_Blur.getMipCount()); mipLevel++)
+ {
+ // mip descriptor writes
+ vkcv::DescriptorWrites mipDescriptorWrites;
+ mipDescriptorWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, m_Blur.getHandle(), mipLevel - 1, true)};
+ mipDescriptorWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(1, m_LinearSampler)};
+ mipDescriptorWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(2, m_Blur.getHandle(), mipLevel) };
+ p_Core->writeDescriptorSet(m_DownsampleDescSets[mipLevel], mipDescriptorWrites);
+
+ // mip dispatch calculation
+ mipDispatchCountX /= 2.0f;
+ mipDispatchCountY /= 2.0f;
+
+ uint32_t mipDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(mipDispatchCountX)),
+ static_cast<uint32_t>(glm::ceil(mipDispatchCountY)),
+ 1
+ };
+
+ if(mipDispatchCount[0] == 0)
+ mipDispatchCount[0] = 1;
+ if(mipDispatchCount[1] == 0)
+ mipDispatchCount[1] = 1;
+
+ // mip blur dispatch
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_DownsamplePipe,
+ mipDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_DownsampleDescSets[mipLevel]).vulkanHandle)},
+ vkcv::PushConstantData(nullptr, 0));
+
+ // image barrier between mips
+ p_Core->recordImageMemoryBarrier(cmdStream, m_Blur.getHandle());
+ }
+}
+
+void BloomAndFlares::execUpsamplePipe(const vkcv::CommandStreamHandle &cmdStream)
+{
+ // upsample dispatch
+ p_Core->prepareImageForStorage(cmdStream, m_Blur.getHandle());
+
+ const uint32_t upsampleMipLevels = std::min(
+ static_cast<uint32_t>(m_UpsampleDescSets.size() - 1),
+ static_cast<uint32_t>(5)
+ );
+
+ // upsample dispatch for each mip map
+ for(uint32_t mipLevel = upsampleMipLevels; mipLevel > 0; mipLevel--)
+ {
+ // mip descriptor writes
+ vkcv::DescriptorWrites mipUpsampleWrites;
+ mipUpsampleWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, m_Blur.getHandle(), mipLevel, true)};
+ mipUpsampleWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(1, m_LinearSampler)};
+ mipUpsampleWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(2, m_Blur.getHandle(), mipLevel - 1) };
+ p_Core->writeDescriptorSet(m_UpsampleDescSets[mipLevel], mipUpsampleWrites);
+
+ auto mipDivisor = glm::pow(2.0f, static_cast<float>(mipLevel) - 1.0f);
+
+ auto upsampleDispatchX = static_cast<float>(m_Width) / mipDivisor;
+ auto upsampleDispatchY = static_cast<float>(m_Height) / mipDivisor;
+ upsampleDispatchX /= 8.0f;
+ upsampleDispatchY /= 8.0f;
+
+ const uint32_t upsampleDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(upsampleDispatchX)),
+ static_cast<uint32_t>(glm::ceil(upsampleDispatchY)),
+ 1
+ };
+
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_UpsamplePipe,
+ upsampleDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_UpsampleDescSets[mipLevel]).vulkanHandle)},
+ vkcv::PushConstantData(nullptr, 0)
+ );
+ // image barrier between mips
+ p_Core->recordImageMemoryBarrier(cmdStream, m_Blur.getHandle());
+ }
+}
+
+void BloomAndFlares::execLensFeaturePipe(const vkcv::CommandStreamHandle &cmdStream)
+{
+ // lens feature generation descriptor writes
+ p_Core->prepareImageForSampling(cmdStream, m_Blur.getHandle());
+ p_Core->prepareImageForStorage(cmdStream, m_LensFeatures.getHandle());
+
+ const uint32_t targetMip = 2;
+ const uint32_t mipLevel = std::min(targetMip, m_LensFeatures.getMipCount());
+
+ vkcv::DescriptorWrites lensFeatureWrites;
+ lensFeatureWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, m_Blur.getHandle(), 0)};
+ lensFeatureWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(1, m_LinearSampler)};
+ lensFeatureWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(2, m_LensFeatures.getHandle(), mipLevel)};
+ p_Core->writeDescriptorSet(m_LensFlareDescSet, lensFeatureWrites);
+
+ auto dispatchCountX = static_cast<float>(m_Width) / 8.0f;
+ auto dispatchCountY = static_cast<float>(m_Height) / 8.0f;
+ // lens feature generation dispatch
+ uint32_t lensFeatureDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(dispatchCountX / std::exp2(mipLevel))),
+ static_cast<uint32_t>(glm::ceil(dispatchCountY / std::exp2(mipLevel))),
+ 1
+ };
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_LensFlarePipe,
+ lensFeatureDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_LensFlareDescSet).vulkanHandle)},
+ vkcv::PushConstantData(nullptr, 0));
+
+ // upsample dispatch
+ p_Core->prepareImageForStorage(cmdStream, m_LensFeatures.getHandle());
+
+ // upsample dispatch for each mip map
+ for (uint32_t i = mipLevel; i > 0; i--)
+ {
+ // mip descriptor writes
+ vkcv::DescriptorWrites mipUpsampleWrites;
+ mipUpsampleWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(0, m_LensFeatures.getHandle(), i, true) };
+ mipUpsampleWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(1, m_LinearSampler) };
+ mipUpsampleWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(2, m_LensFeatures.getHandle(), i - 1) };
+ p_Core->writeDescriptorSet(m_UpsampleLensFlareDescSets[i], mipUpsampleWrites);
+
+ auto mipDivisor = glm::pow(2.0f, static_cast<float>(i) - 1.0f);
+
+ auto upsampleDispatchX = static_cast<float>(m_Width) / mipDivisor;
+ auto upsampleDispatchY = static_cast<float>(m_Height) / mipDivisor;
+ upsampleDispatchX /= 8.0f;
+ upsampleDispatchY /= 8.0f;
+
+ const uint32_t upsampleDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(upsampleDispatchX)),
+ static_cast<uint32_t>(glm::ceil(upsampleDispatchY)),
+ 1
+ };
+
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_UpsamplePipe,
+ upsampleDispatchCount,
+ { vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_UpsampleLensFlareDescSets[i]).vulkanHandle) },
+ vkcv::PushConstantData(nullptr, 0)
+ );
+ // image barrier between mips
+ p_Core->recordImageMemoryBarrier(cmdStream, m_LensFeatures.getHandle());
+ }
+}
+
+void BloomAndFlares::execCompositePipe(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle& colorAttachment,
+ const uint32_t attachmentWidth, const uint32_t attachmentHeight, const glm::vec3& cameraForward)
+{
+ p_Core->prepareImageForSampling(cmdStream, m_Blur.getHandle());
+ p_Core->prepareImageForSampling(cmdStream, m_LensFeatures.getHandle());
+ p_Core->prepareImageForStorage(cmdStream, colorAttachment);
+
+ // bloom composite descriptor write
+ vkcv::DescriptorWrites compositeWrites;
+ compositeWrites.sampledImageWrites = {vkcv::SampledImageDescriptorWrite(0, m_Blur.getHandle()),
+ vkcv::SampledImageDescriptorWrite(1, m_LensFeatures.getHandle()),
+ vkcv::SampledImageDescriptorWrite(4, m_radialLut.getHandle()),
+ vkcv::SampledImageDescriptorWrite(6, m_lensDirt.getHandle()) };
+ compositeWrites.samplerWrites = {vkcv::SamplerDescriptorWrite(2, m_LinearSampler),
+ vkcv::SamplerDescriptorWrite(5, m_RadialLutSampler) };
+ compositeWrites.storageImageWrites = {vkcv::StorageImageDescriptorWrite(3, colorAttachment)};
+ p_Core->writeDescriptorSet(m_CompositeDescSet, compositeWrites);
+
+ float dispatchCountX = static_cast<float>(attachmentWidth) / 8.0f;
+ float dispatchCountY = static_cast<float>(attachmentHeight) / 8.0f;
+
+ uint32_t compositeDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(dispatchCountX)),
+ static_cast<uint32_t>(glm::ceil(dispatchCountY)),
+ 1
+ };
+
+ // bloom composite dispatch
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_CompositePipe,
+ compositeDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_CompositeDescSet).vulkanHandle)},
+ vkcv::PushConstantData((void*)&cameraForward, sizeof(cameraForward)));
+}
+
+void BloomAndFlares::execWholePipeline(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle &colorAttachment,
+ const uint32_t attachmentWidth, const uint32_t attachmentHeight, const glm::vec3& cameraForward)
+{
+ execDownsamplePipe(cmdStream, colorAttachment);
+ execUpsamplePipe(cmdStream);
+ execLensFeaturePipe(cmdStream);
+ execCompositePipe(cmdStream, colorAttachment, attachmentWidth, attachmentHeight, cameraForward);
+}
+
+void BloomAndFlares::updateImageDimensions(uint32_t width, uint32_t height)
+{
+ m_Width = width / 2;
+ m_Height = height / 2;
+
+ p_Core->getContext().getDevice().waitIdle();
+ m_Blur = p_Core->createImage(m_ColorBufferFormat, m_Width, m_Height, 1, true, true, false);
+ m_LensFeatures = p_Core->createImage(m_ColorBufferFormat, m_Width, m_Height, 1, true, true, false);
+}
+
+
diff --git a/projects/voxelization/src/BloomAndFlares.hpp b/projects/voxelization/src/BloomAndFlares.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b410e5b256c5820d908372d2e23fd495853274a
--- /dev/null
+++ b/projects/voxelization/src/BloomAndFlares.hpp
@@ -0,0 +1,53 @@
+#pragma once
+#include <vkcv/Core.hpp>
+#include <glm/glm.hpp>
+
+class BloomAndFlares{
+public:
+ BloomAndFlares(vkcv::Core *p_Core,
+ vk::Format colorBufferFormat,
+ uint32_t width,
+ uint32_t height);
+
+ void execWholePipeline(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle &colorAttachment,
+ const uint32_t attachmentWidth, const uint32_t attachmentHeight, const glm::vec3& cameraForward);
+
+ void updateImageDimensions(uint32_t width, uint32_t height);
+
+private:
+ vkcv::Core *p_Core;
+
+ vk::Format m_ColorBufferFormat;
+ uint32_t m_Width;
+ uint32_t m_Height;
+
+ vkcv::SamplerHandle m_LinearSampler;
+ vkcv::SamplerHandle m_RadialLutSampler;
+ vkcv::Image m_Blur;
+ vkcv::Image m_LensFeatures;
+
+ vkcv::Image m_radialLut;
+ vkcv::Image m_lensDirt;
+
+ vkcv::PipelineHandle m_DownsamplePipe;
+ std::vector<vkcv::DescriptorSetHandle> m_DownsampleDescSets; // per mip desc set
+ std::vector<vkcv::DescriptorSetHandle> m_UpsampleLensFlareDescSets; // per mip desc set
+
+ vkcv::PipelineHandle m_UpsamplePipe;
+ std::vector<vkcv::DescriptorSetHandle> m_UpsampleDescSets; // per mip desc set
+
+ vkcv::PipelineHandle m_LensFlarePipe;
+ vkcv::DescriptorSetHandle m_LensFlareDescSet;
+
+ vkcv::PipelineHandle m_CompositePipe;
+ vkcv::DescriptorSetHandle m_CompositeDescSet;
+
+ void execDownsamplePipe(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle &colorAttachment);
+ void execUpsamplePipe(const vkcv::CommandStreamHandle &cmdStream);
+ void execLensFeaturePipe(const vkcv::CommandStreamHandle &cmdStream);
+ void execCompositePipe(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle &colorAttachment,
+ const uint32_t attachmentWidth, const uint32_t attachmentHeight, const glm::vec3& cameraForward);
+};
+
+
+
diff --git a/projects/voxelization/src/ShadowMapping.cpp b/projects/voxelization/src/ShadowMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a330394b7bd7ff2a4b8c347bd79e676dbc70f846
--- /dev/null
+++ b/projects/voxelization/src/ShadowMapping.cpp
@@ -0,0 +1,321 @@
+#include "ShadowMapping.hpp"
+#include <vkcv/shader/GLSLCompiler.hpp>
+
+const vk::Format shadowMapFormat = vk::Format::eR16G16B16A16Unorm;
+const vk::Format shadowMapDepthFormat = vk::Format::eD32Sfloat;
+const uint32_t shadowMapResolution = 1024;
+const vkcv::Multisampling msaa = vkcv::Multisampling::MSAA8X;
+
+vkcv::ShaderProgram loadShadowShader() {
+ vkcv::ShaderProgram shader;
+ vkcv::shader::GLSLCompiler compiler;
+ compiler.compile(vkcv::ShaderStage::VERTEX, "resources/shaders/shadow.vert",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ shader.addShader(shaderStage, path);
+ });
+ compiler.compile(vkcv::ShaderStage::FRAGMENT, "resources/shaders/shadow.frag",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ shader.addShader(shaderStage, path);
+ });
+ return shader;
+}
+
+vkcv::ShaderProgram loadDepthToMomentsShader() {
+ vkcv::ShaderProgram shader;
+ vkcv::shader::GLSLCompiler compiler;
+ compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/depthToMoments.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ shader.addShader(shaderStage, path);
+ });
+ return shader;
+}
+
+vkcv::ShaderProgram loadShadowBlurXShader() {
+ vkcv::ShaderProgram shader;
+ vkcv::shader::GLSLCompiler compiler;
+ compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/shadowBlurX.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ shader.addShader(shaderStage, path);
+ });
+ return shader;
+}
+
+vkcv::ShaderProgram loadShadowBlurYShader() {
+ vkcv::ShaderProgram shader;
+ vkcv::shader::GLSLCompiler compiler;
+ compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/shadowBlurY.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ shader.addShader(shaderStage, path);
+ });
+ return shader;
+}
+
+glm::mat4 computeShadowViewProjectionMatrix(
+ const glm::vec3& lightDirection,
+ const vkcv::camera::Camera& camera,
+ float maxShadowDistance,
+ const glm::vec3& voxelVolumeOffset,
+ float voxelVolumeExtent) {
+
+ const glm::vec3 cameraPos = camera.getPosition();
+ const glm::vec3 forward = glm::normalize(camera.getFront());
+ glm::vec3 up = glm::normalize(camera.getUp());
+ const glm::vec3 right = glm::normalize(glm::cross(forward, up));
+ up = glm::cross(right, forward);
+
+ const float fov = camera.getFov();
+ const float aspectRatio = camera.getRatio();
+
+ float near;
+ float far;
+ camera.getNearFar(near, far);
+ far = std::min(maxShadowDistance, far);
+
+ const glm::vec3 nearCenter = cameraPos + forward * near;
+ const float nearUp = near * tan(fov * 0.5);
+ const float nearRight = nearUp * aspectRatio;
+
+ const glm::vec3 farCenter = cameraPos + forward * far;
+ const float farUp = far * tan(fov * 0.5);
+ const float farRight = farUp * aspectRatio;
+
+ std::array<glm::vec3, 8> viewFrustumCorners = {
+ nearCenter + right * nearRight + nearUp * up,
+ nearCenter + right * nearRight - nearUp * up,
+ nearCenter - right * nearRight + nearUp * up,
+ nearCenter - right * nearRight - nearUp * up,
+
+ farCenter + right * farRight + farUp * up,
+ farCenter + right * farRight - farUp * up,
+ farCenter - right * farRight + farUp * up,
+ farCenter - right * farRight - farUp * up
+ };
+
+ std::array<glm::vec3, 8> voxelVolumeCorners = {
+ voxelVolumeOffset + voxelVolumeExtent * glm::vec3(1, 1, 1),
+ voxelVolumeOffset + voxelVolumeExtent * glm::vec3(1, 1, -1),
+ voxelVolumeOffset + voxelVolumeExtent * glm::vec3(1, -1, 1),
+ voxelVolumeOffset + voxelVolumeExtent * glm::vec3(1, -1, -1),
+
+ voxelVolumeOffset + voxelVolumeExtent * glm::vec3(-1, 1, 1),
+ voxelVolumeOffset + voxelVolumeExtent * glm::vec3(-1, 1, -1),
+ voxelVolumeOffset + voxelVolumeExtent * glm::vec3(-1, -1, 1),
+ voxelVolumeOffset + voxelVolumeExtent * glm::vec3(-1, -1, -1),
+ };
+
+ glm::vec3 minView(std::numeric_limits<float>::max());
+ glm::vec3 maxView(std::numeric_limits<float>::lowest());
+
+ const glm::mat4 view = glm::lookAt(glm::vec3(0), -lightDirection, glm::vec3(0, -1, 0));
+
+ auto getMinMaxView = [&](std::array<glm::vec3, 8> points) {
+ for (const glm::vec3& p : points) {
+ const auto& pView = glm::vec3(view * glm::vec4(p, 1));
+ minView = glm::min(minView, pView);
+ maxView = glm::max(maxView, pView);
+ }
+ };
+
+ getMinMaxView(viewFrustumCorners);
+ getMinMaxView(voxelVolumeCorners);
+
+ // rotationaly invariant to avoid shadow swimming when moving camera
+ // could potentially be wasteful, but guarantees stability, regardless of camera and voxel volume
+ glm::vec3 scale = glm::vec3(1.f / glm::max(far, voxelVolumeExtent));
+
+ glm::vec3 offset = -0.5f * (maxView + minView) * scale;
+
+ // snap to texel to avoid shadow swimming when moving
+ glm::vec2 offset2D = glm::vec2(offset);
+ glm::vec2 frustumExtent2D = glm::vec2(1) / glm::vec2(scale);
+ glm::vec2 texelSize = glm::vec2(frustumExtent2D / static_cast<float>(shadowMapResolution));
+ offset2D = glm::ceil(offset2D / texelSize) * texelSize;
+ offset.x = offset2D.x;
+ offset.y = offset2D.y;
+
+ glm::mat4 crop(1);
+ crop[0][0] = scale.x;
+ crop[1][1] = scale.y;
+ crop[2][2] = scale.z;
+
+ crop[3][0] = offset.x;
+ crop[3][1] = offset.y;
+ crop[3][2] = offset.z;
+
+ glm::mat4 vulkanCorrectionMatrix(1.f);
+ vulkanCorrectionMatrix[2][2] = 0.5;
+ vulkanCorrectionMatrix[3][2] = 0.5;
+
+ return vulkanCorrectionMatrix * crop * view;
+}
+
+ShadowMapping::ShadowMapping(vkcv::Core* corePtr, const vkcv::VertexLayout& vertexLayout) :
+ m_corePtr(corePtr),
+ m_shadowMap(corePtr->createImage(shadowMapFormat, shadowMapResolution, shadowMapResolution, 1, true, true)),
+ m_shadowMapIntermediate(corePtr->createImage(shadowMapFormat, shadowMapResolution, shadowMapResolution, 1, false, true)),
+ m_shadowMapDepth(corePtr->createImage(shadowMapDepthFormat, shadowMapResolution, shadowMapResolution, 1, false, false, false, msaa)),
+ m_lightInfoBuffer(corePtr->createBuffer<LightInfo>(vkcv::BufferType::UNIFORM, sizeof(glm::vec3))){
+
+ vkcv::ShaderProgram shadowShader = loadShadowShader();
+
+ // pass
+ const std::vector<vkcv::AttachmentDescription> shadowAttachments = {
+ vkcv::AttachmentDescription(vkcv::AttachmentOperation::STORE, vkcv::AttachmentOperation::CLEAR, shadowMapDepthFormat)
+ };
+ vkcv::PassConfig shadowPassConfig(shadowAttachments, msaa);
+ m_shadowMapPass = corePtr->createPass(shadowPassConfig);
+
+ // pipeline
+ vkcv::PipelineConfig shadowPipeConfig{
+ shadowShader,
+ shadowMapResolution,
+ shadowMapResolution,
+ m_shadowMapPass,
+ vertexLayout,
+ {},
+ false
+ };
+ shadowPipeConfig.m_multisampling = msaa;
+ shadowPipeConfig.m_EnableDepthClamping = true;
+ shadowPipeConfig.m_culling = vkcv::CullMode::Front;
+ m_shadowMapPipe = corePtr->createGraphicsPipeline(shadowPipeConfig);
+
+ m_shadowSampler = corePtr->createSampler(
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::CLAMP_TO_EDGE
+ );
+
+ // depth to moments
+ vkcv::ShaderProgram depthToMomentsShader = loadDepthToMomentsShader();
+ m_depthToMomentsDescriptorSet = corePtr->createDescriptorSet(depthToMomentsShader.getReflectedDescriptors()[0]);
+ m_depthToMomentsPipe = corePtr->createComputePipeline(depthToMomentsShader, { corePtr->getDescriptorSet(m_depthToMomentsDescriptorSet).layout });
+
+ vkcv::DescriptorWrites depthToMomentDescriptorWrites;
+ depthToMomentDescriptorWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(0, m_shadowMapDepth.getHandle()) };
+ depthToMomentDescriptorWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(1, m_shadowSampler) };
+ depthToMomentDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(2, m_shadowMap.getHandle()) };
+ corePtr->writeDescriptorSet(m_depthToMomentsDescriptorSet, depthToMomentDescriptorWrites);
+
+ // shadow blur X
+ vkcv::ShaderProgram shadowBlurXShader = loadShadowBlurXShader();
+ m_shadowBlurXDescriptorSet = corePtr->createDescriptorSet(shadowBlurXShader.getReflectedDescriptors()[0]);
+ m_shadowBlurXPipe = corePtr->createComputePipeline(shadowBlurXShader, { corePtr->getDescriptorSet(m_shadowBlurXDescriptorSet).layout });
+
+ vkcv::DescriptorWrites shadowBlurXDescriptorWrites;
+ shadowBlurXDescriptorWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(0, m_shadowMap.getHandle()) };
+ shadowBlurXDescriptorWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(1, m_shadowSampler) };
+ shadowBlurXDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(2, m_shadowMapIntermediate.getHandle()) };
+ corePtr->writeDescriptorSet(m_shadowBlurXDescriptorSet, shadowBlurXDescriptorWrites);
+
+ // shadow blur Y
+ vkcv::ShaderProgram shadowBlurYShader = loadShadowBlurYShader();
+ m_shadowBlurYDescriptorSet = corePtr->createDescriptorSet(shadowBlurYShader.getReflectedDescriptors()[0]);
+ m_shadowBlurYPipe = corePtr->createComputePipeline(shadowBlurYShader, { corePtr->getDescriptorSet(m_shadowBlurYDescriptorSet).layout });
+
+ vkcv::DescriptorWrites shadowBlurYDescriptorWrites;
+ shadowBlurYDescriptorWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(0, m_shadowMapIntermediate.getHandle()) };
+ shadowBlurYDescriptorWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(1, m_shadowSampler) };
+ shadowBlurYDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(2, m_shadowMap.getHandle()) };
+ corePtr->writeDescriptorSet(m_shadowBlurYDescriptorSet, shadowBlurYDescriptorWrites);
+}
+
+void ShadowMapping::recordShadowMapRendering(
+ const vkcv::CommandStreamHandle& cmdStream,
+ const glm::vec2& lightAngleRadian,
+ const glm::vec3& lightColor,
+ float lightStrength,
+ float maxShadowDistance,
+ const std::vector<vkcv::Mesh>& meshes,
+ const std::vector<glm::mat4>& modelMatrices,
+ const vkcv::camera::Camera& camera,
+ const glm::vec3& voxelVolumeOffset,
+ float voxelVolumeExtent) {
+
+ LightInfo lightInfo;
+ lightInfo.sunColor = lightColor;
+ lightInfo.sunStrength = lightStrength;
+ lightInfo.direction = glm::normalize(glm::vec3(
+ std::cos(lightAngleRadian.x) * std::cos(lightAngleRadian.y),
+ std::sin(lightAngleRadian.x),
+ std::cos(lightAngleRadian.x) * std::sin(lightAngleRadian.y)));
+
+ lightInfo.lightMatrix = computeShadowViewProjectionMatrix(
+ lightInfo.direction,
+ camera,
+ maxShadowDistance,
+ voxelVolumeOffset,
+ voxelVolumeExtent);
+ m_lightInfoBuffer.fill({ lightInfo });
+
+ std::vector<glm::mat4> mvpLight;
+ for (const auto& m : modelMatrices) {
+ mvpLight.push_back(lightInfo.lightMatrix * m);
+ }
+ const vkcv::PushConstantData shadowPushConstantData((void*)mvpLight.data(), sizeof(glm::mat4));
+
+ std::vector<vkcv::DrawcallInfo> drawcalls;
+ for (const auto& mesh : meshes) {
+ drawcalls.push_back(vkcv::DrawcallInfo(mesh, {}));
+ }
+
+ m_corePtr->recordDrawcallsToCmdStream(
+ cmdStream,
+ m_shadowMapPass,
+ m_shadowMapPipe,
+ shadowPushConstantData,
+ drawcalls,
+ { m_shadowMapDepth.getHandle() });
+ m_corePtr->prepareImageForSampling(cmdStream, m_shadowMapDepth.getHandle());
+
+ // depth to moments
+ uint32_t dispatchCount[3];
+ dispatchCount[0] = static_cast<uint32_t>(std::ceil(shadowMapResolution / 8.f));
+ dispatchCount[1] = static_cast<uint32_t>(std::ceil(shadowMapResolution / 8.f));
+ dispatchCount[2] = 1;
+
+ const uint32_t msaaSampleCount = msaaToSampleCount(msaa);
+
+ m_corePtr->prepareImageForStorage(cmdStream, m_shadowMap.getHandle());
+ m_corePtr->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_depthToMomentsPipe,
+ dispatchCount,
+ { vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_depthToMomentsDescriptorSet).vulkanHandle) },
+ vkcv::PushConstantData((void*)&msaaSampleCount, sizeof(msaaSampleCount)));
+ m_corePtr->prepareImageForSampling(cmdStream, m_shadowMap.getHandle());
+
+ // blur X
+ m_corePtr->prepareImageForStorage(cmdStream, m_shadowMapIntermediate.getHandle());
+ m_corePtr->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_shadowBlurXPipe,
+ dispatchCount,
+ { vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_shadowBlurXDescriptorSet).vulkanHandle) },
+ vkcv::PushConstantData(nullptr, 0));
+ m_corePtr->prepareImageForSampling(cmdStream, m_shadowMapIntermediate.getHandle());
+
+ // blur Y
+ m_corePtr->prepareImageForStorage(cmdStream, m_shadowMap.getHandle());
+ m_corePtr->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_shadowBlurYPipe,
+ dispatchCount,
+ { vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_shadowBlurYDescriptorSet).vulkanHandle) },
+ vkcv::PushConstantData(nullptr, 0));
+ m_shadowMap.recordMipChainGeneration(cmdStream);
+ m_corePtr->prepareImageForSampling(cmdStream, m_shadowMap.getHandle());
+}
+
+vkcv::ImageHandle ShadowMapping::getShadowMap() {
+ return m_shadowMap.getHandle();
+}
+
+vkcv::SamplerHandle ShadowMapping::getShadowSampler() {
+ return m_shadowSampler;
+}
+
+vkcv::BufferHandle ShadowMapping::getLightInfoBuffer() {
+ return m_lightInfoBuffer.getHandle();
+}
\ No newline at end of file
diff --git a/projects/voxelization/src/ShadowMapping.hpp b/projects/voxelization/src/ShadowMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8066d5bdc90a66c0823be4dc23cf6a12729e32c7
--- /dev/null
+++ b/projects/voxelization/src/ShadowMapping.hpp
@@ -0,0 +1,56 @@
+#pragma once
+#include <vkcv/Core.hpp>
+#include <vkcv/camera/Camera.hpp>
+
+#include <glm/glm.hpp>
+#include <glm/gtx/transform.hpp>
+
+struct LightInfo {
+ glm::vec3 direction;
+ float padding;
+ glm::vec3 sunColor;
+ float sunStrength;
+ glm::mat4 lightMatrix;
+};
+
+class ShadowMapping {
+public:
+ ShadowMapping(vkcv::Core* corePtr, const vkcv::VertexLayout& vertexLayout);
+
+ void recordShadowMapRendering(
+ const vkcv::CommandStreamHandle& cmdStream,
+ const glm::vec2& lightAngleRadian,
+ const glm::vec3& lightColor,
+ float lightStrength,
+ float maxShadowDistance,
+ const std::vector<vkcv::Mesh>& meshes,
+ const std::vector<glm::mat4>& modelMatrices,
+ const vkcv::camera::Camera& camera,
+ const glm::vec3& voxelVolumeOffset,
+ float voxelVolumeExtent);
+
+ vkcv::ImageHandle getShadowMap();
+ vkcv::SamplerHandle getShadowSampler();
+ vkcv::BufferHandle getLightInfoBuffer();
+
+private:
+ vkcv::Core* m_corePtr;
+
+ vkcv::Image m_shadowMap;
+ vkcv::Image m_shadowMapIntermediate;
+ vkcv::Image m_shadowMapDepth;
+ vkcv::SamplerHandle m_shadowSampler;
+ vkcv::Buffer<LightInfo> m_lightInfoBuffer;
+
+ vkcv::PassHandle m_shadowMapPass;
+ vkcv::PipelineHandle m_shadowMapPipe;
+
+ vkcv::PipelineHandle m_depthToMomentsPipe;
+ vkcv::DescriptorSetHandle m_depthToMomentsDescriptorSet;
+
+ vkcv::PipelineHandle m_shadowBlurXPipe;
+ vkcv::DescriptorSetHandle m_shadowBlurXDescriptorSet;
+
+ vkcv::PipelineHandle m_shadowBlurYPipe;
+ vkcv::DescriptorSetHandle m_shadowBlurYDescriptorSet;
+};
\ No newline at end of file
diff --git a/projects/voxelization/src/Voxelization.cpp b/projects/voxelization/src/Voxelization.cpp
index a04131cedfdc508e14a3dbd97da642e1af48f8da..c117b4b9e6b896fbf51aae83343f30281061be9f 100644
--- a/projects/voxelization/src/Voxelization.cpp
+++ b/projects/voxelization/src/Voxelization.cpp
@@ -59,19 +59,33 @@ vkcv::ShaderProgram loadVoxelBufferToImageShader() {
return shader;
}
-const uint32_t voxelResolution = 128;
-uint32_t voxelCount = voxelResolution * voxelResolution * voxelResolution;
-const vk::Format voxelizationDummyFormat = vk::Format::eR8Unorm;
+vkcv::ShaderProgram loadSecondaryBounceShader() {
+ vkcv::shader::GLSLCompiler compiler;
+ vkcv::ShaderProgram shader;
+ compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/voxelSecondaryBounce.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ shader.addShader(shaderStage, path);
+ });
+ return shader;
+}
+
+const uint32_t voxelResolution = 128;
+uint32_t voxelCount = voxelResolution * voxelResolution * voxelResolution;
+const vk::Format voxelizationDummyFormat = vk::Format::eR8Unorm;
+const int maxStableMip = 4; // must be the same as in voxelConeTrace shader function
Voxelization::Voxelization(
vkcv::Core* corePtr,
const Dependencies& dependencies,
vkcv::BufferHandle lightInfoBuffer,
vkcv::ImageHandle shadowMap,
- vkcv::SamplerHandle shadowSampler)
+ vkcv::SamplerHandle shadowSampler,
+ vkcv::SamplerHandle voxelSampler,
+ vkcv::Multisampling msaa)
:
m_corePtr(corePtr),
m_voxelImage(m_corePtr->createImage(vk::Format::eR16G16B16A16Sfloat, voxelResolution, voxelResolution, voxelResolution, true, true)),
+ m_voxelImageIntermediate(m_corePtr->createImage(vk::Format::eR16G16B16A16Sfloat, voxelResolution, voxelResolution, voxelResolution, true, true)),
m_dummyRenderTarget(m_corePtr->createImage(voxelizationDummyFormat, voxelResolution, voxelResolution, 1, false, false, true)),
m_voxelInfoBuffer(m_corePtr->createBuffer<VoxelizationInfo>(vkcv::BufferType::UNIFORM, 1)),
m_voxelBuffer(m_corePtr->createBuffer<VoxelBufferContent>(vkcv::BufferType::STORAGE, voxelCount)){
@@ -112,7 +126,7 @@ Voxelization::Voxelization(
};
voxelizationDescriptorWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(4, shadowMap) };
voxelizationDescriptorWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(5, shadowSampler) };
- voxelizationDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(2, m_voxelImage.getHandle()) };
+ voxelizationDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(2, m_voxelImageIntermediate.getHandle()) };
m_corePtr->writeDescriptorSet(m_voxelizationDescriptorSet, voxelizationDescriptorWrites);
vkcv::ShaderProgram voxelVisualisationShader = loadVoxelVisualisationShader();
@@ -135,9 +149,10 @@ Voxelization::Voxelization(
vkcv::PassConfig voxelVisualisationPassDefinition(
{ voxelVisualisationColorAttachments, voxelVisualisationDepthAttachments });
+ voxelVisualisationPassDefinition.msaa = msaa;
m_visualisationPass = m_corePtr->createPass(voxelVisualisationPassDefinition);
- const vkcv::PipelineConfig voxelVisualisationPipeConfig{
+ vkcv::PipelineConfig voxelVisualisationPipeConfig{
voxelVisualisationShader,
0,
0,
@@ -147,6 +162,7 @@ Voxelization::Voxelization(
true,
false,
vkcv::PrimitiveTopology::PointList }; // points are extended to cubes in the geometry shader
+ voxelVisualisationPipeConfig.m_multisampling = msaa;
m_visualisationPipe = m_corePtr->createGraphicsPipeline(voxelVisualisationPipeConfig);
std::vector<uint16_t> voxelIndexData;
@@ -167,7 +183,7 @@ Voxelization::Voxelization(
resetVoxelWrites.storageBufferWrites = { vkcv::StorageBufferDescriptorWrite(0, m_voxelBuffer.getHandle()) };
m_corePtr->writeDescriptorSet(m_voxelResetDescriptorSet, resetVoxelWrites);
-
+ // buffer to image
vkcv::ShaderProgram bufferToImageShader = loadVoxelBufferToImageShader();
m_bufferToImageDescriptorSet = m_corePtr->createDescriptorSet(bufferToImageShader.getReflectedDescriptors()[0]);
@@ -177,27 +193,35 @@ Voxelization::Voxelization(
vkcv::DescriptorWrites bufferToImageDescriptorWrites;
bufferToImageDescriptorWrites.storageBufferWrites = { vkcv::StorageBufferDescriptorWrite(0, m_voxelBuffer.getHandle()) };
- bufferToImageDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(1, m_voxelImage.getHandle()) };
+ bufferToImageDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(1, m_voxelImageIntermediate.getHandle()) };
m_corePtr->writeDescriptorSet(m_bufferToImageDescriptorSet, bufferToImageDescriptorWrites);
+
+ // secondary bounce
+ vkcv::ShaderProgram secondaryBounceShader = loadSecondaryBounceShader();
+
+ m_secondaryBounceDescriptorSet = m_corePtr->createDescriptorSet(secondaryBounceShader.getReflectedDescriptors()[0]);
+ m_secondaryBouncePipe = m_corePtr->createComputePipeline(
+ secondaryBounceShader,
+ { m_corePtr->getDescriptorSet(m_secondaryBounceDescriptorSet).layout });
+
+ vkcv::DescriptorWrites secondaryBounceDescriptorWrites;
+ secondaryBounceDescriptorWrites.storageBufferWrites = { vkcv::StorageBufferDescriptorWrite(0, m_voxelBuffer.getHandle()) };
+ secondaryBounceDescriptorWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(1, m_voxelImageIntermediate.getHandle()) };
+ secondaryBounceDescriptorWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(2, voxelSampler) };
+ secondaryBounceDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(3, m_voxelImage.getHandle()) };
+ secondaryBounceDescriptorWrites.uniformBufferWrites = { vkcv::UniformBufferDescriptorWrite(4, m_voxelInfoBuffer.getHandle()) };
+ m_corePtr->writeDescriptorSet(m_secondaryBounceDescriptorSet, secondaryBounceDescriptorWrites);
}
void Voxelization::voxelizeMeshes(
- vkcv::CommandStreamHandle cmdStream,
- const glm::vec3& cameraPosition,
+ vkcv::CommandStreamHandle cmdStream,
const std::vector<vkcv::Mesh>& meshes,
const std::vector<glm::mat4>& modelMatrices,
const std::vector<vkcv::DescriptorSetHandle>& perMeshDescriptorSets) {
- VoxelizationInfo voxelizationInfo;
- voxelizationInfo.extent = m_voxelExtent;
-
- // move voxel offset with camera in voxel sized steps
- const float voxelSize = m_voxelExtent / voxelResolution;
- voxelizationInfo.offset = glm::floor(cameraPosition / voxelSize) * voxelSize;
+ m_voxelInfoBuffer.fill({ m_voxelInfo });
- m_voxelInfoBuffer.fill({ voxelizationInfo });
-
- const float voxelizationHalfExtent = 0.5f * m_voxelExtent;
+ const float voxelizationHalfExtent = 0.5f * m_voxelInfo.extent;
const glm::mat4 voxelizationProjection = glm::ortho(
-voxelizationHalfExtent,
voxelizationHalfExtent,
@@ -206,7 +230,7 @@ void Voxelization::voxelizeMeshes(
-voxelizationHalfExtent,
voxelizationHalfExtent);
- const glm::mat4 voxelizationView = glm::translate(glm::mat4(1.f), -voxelizationInfo.offset);
+ const glm::mat4 voxelizationView = glm::translate(glm::mat4(1.f), -m_voxelInfo.offset);
const glm::mat4 voxelizationViewProjection = voxelizationProjection * voxelizationView;
std::vector<std::array<glm::mat4, 2>> voxelizationMatrices;
@@ -223,7 +247,6 @@ void Voxelization::voxelizeMeshes(
resetVoxelDispatchCount[1] = 1;
resetVoxelDispatchCount[2] = 1;
- m_corePtr->prepareImageForStorage(cmdStream, m_voxelImage.getHandle());
m_corePtr->recordComputeDispatchToCmdStream(
cmdStream,
m_voxelResetPipe,
@@ -240,9 +263,10 @@ void Voxelization::voxelizeMeshes(
{
vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_voxelizationDescriptorSet).vulkanHandle),
vkcv::DescriptorSetUsage(1, m_corePtr->getDescriptorSet(perMeshDescriptorSets[i]).vulkanHandle)
- }));
+ },1));
}
+ m_corePtr->prepareImageForStorage(cmdStream, m_voxelImageIntermediate.getHandle());
m_corePtr->recordDrawcallsToCmdStream(
cmdStream,
m_voxelizationPass,
@@ -265,9 +289,28 @@ void Voxelization::voxelizeMeshes(
{ vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_bufferToImageDescriptorSet).vulkanHandle) },
vkcv::PushConstantData(nullptr, 0));
+ m_corePtr->recordImageMemoryBarrier(cmdStream, m_voxelImageIntermediate.getHandle());
+
+ // intermediate image mipchain
+ m_voxelImageIntermediate.recordMipChainGeneration(cmdStream);
+ m_corePtr->prepareImageForSampling(cmdStream, m_voxelImageIntermediate.getHandle());
+
+ // secondary bounce
+ m_corePtr->prepareImageForStorage(cmdStream, m_voxelImage.getHandle());
+
+ m_corePtr->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_secondaryBouncePipe,
+ bufferToImageDispatchCount,
+ { vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_secondaryBounceDescriptorSet).vulkanHandle) },
+ vkcv::PushConstantData(nullptr, 0));
+ m_voxelImage.recordMipChainGeneration(cmdStream);
+
m_corePtr->recordImageMemoryBarrier(cmdStream, m_voxelImage.getHandle());
+ // final image mipchain
m_voxelImage.recordMipChainGeneration(cmdStream);
+ m_corePtr->prepareImageForSampling(cmdStream, m_voxelImage.getHandle());
}
void Voxelization::renderVoxelVisualisation(
@@ -292,8 +335,9 @@ void Voxelization::renderVoxelVisualisation(
const auto drawcall = vkcv::DrawcallInfo(
vkcv::Mesh({}, nullptr, drawVoxelCount),
- { vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_visualisationDescriptorSet).vulkanHandle) });
+ { vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_visualisationDescriptorSet).vulkanHandle) },1);
+ m_corePtr->prepareImageForStorage(cmdStream, m_voxelImage.getHandle());
m_corePtr->recordDrawcallsToCmdStream(
cmdStream,
m_visualisationPass,
@@ -303,6 +347,33 @@ void Voxelization::renderVoxelVisualisation(
renderTargets);
}
+void Voxelization::updateVoxelOffset(const vkcv::camera::Camera& camera) {
+
+ // move voxel offset with camera in voxel sized steps
+ const float voxelSize = m_voxelInfo.extent / voxelResolution;
+ const float snapSize = voxelSize * exp2(maxStableMip);
+
+ glm::vec3 voxelVolumeCenter = camera.getPosition() + (1.f / 3.f) * m_voxelInfo.extent * glm::normalize(camera.getFront());
+ voxelVolumeCenter.y = camera.getPosition().y;
+ m_voxelInfo.offset = glm::floor(voxelVolumeCenter / snapSize) * snapSize;
+}
+
void Voxelization::setVoxelExtent(float extent) {
- m_voxelExtent = extent;
-}
\ No newline at end of file
+ m_voxelInfo.extent = extent;
+}
+
+vkcv::ImageHandle Voxelization::getVoxelImageHandle() const {
+ return m_voxelImage.getHandle();
+}
+
+vkcv::BufferHandle Voxelization::getVoxelInfoBufferHandle() const {
+ return m_voxelInfoBuffer.getHandle();
+}
+
+glm::vec3 Voxelization::getVoxelOffset() const{
+ return m_voxelInfo.offset;
+}
+
+float Voxelization::getVoxelExtent() const {
+ return m_voxelInfo.extent;
+}
diff --git a/projects/voxelization/src/Voxelization.hpp b/projects/voxelization/src/Voxelization.hpp
index 25830b171edb9154e37b2d597c2bbbf2daea6b2e..66c87acb3c13c0d950a28dc33e4084d728da5947 100644
--- a/projects/voxelization/src/Voxelization.hpp
+++ b/projects/voxelization/src/Voxelization.hpp
@@ -1,6 +1,7 @@
#pragma once
#include <vkcv/Core.hpp>
#include <glm/glm.hpp>
+#include <vkcv/camera/Camera.hpp>
class Voxelization{
public:
@@ -14,11 +15,12 @@ public:
const Dependencies& dependencies,
vkcv::BufferHandle lightInfoBuffer,
vkcv::ImageHandle shadowMap,
- vkcv::SamplerHandle shadowSampler);
+ vkcv::SamplerHandle shadowSampler,
+ vkcv::SamplerHandle voxelSampler,
+ vkcv::Multisampling msaa);
void voxelizeMeshes(
- vkcv::CommandStreamHandle cmdStream,
- const glm::vec3& cameraPosition,
+ vkcv::CommandStreamHandle cmdStream,
const std::vector<vkcv::Mesh>& meshes,
const std::vector<glm::mat4>& modelMatrices,
const std::vector<vkcv::DescriptorSetHandle>& perMeshDescriptorSets);
@@ -29,17 +31,27 @@ public:
const std::vector<vkcv::ImageHandle>& renderTargets,
uint32_t mipLevel);
+ void updateVoxelOffset(const vkcv::camera::Camera& camera);
void setVoxelExtent(float extent);
+ vkcv::ImageHandle getVoxelImageHandle() const;
+ vkcv::BufferHandle getVoxelInfoBufferHandle() const;
+
+ glm::vec3 getVoxelOffset() const;
+ float getVoxelExtent() const;
+
private:
vkcv::Core* m_corePtr;
struct VoxelBufferContent{
- uint32_t isFilled;
+ uint32_t lightEncoded;
+ uint32_t normalEncoded;
+ uint32_t albedoEncoded;
};
+ vkcv::Image m_voxelImageIntermediate;
vkcv::Image m_voxelImage;
- vkcv::Buffer<VoxelBufferContent> m_voxelBuffer;
+ vkcv::Buffer<VoxelBufferContent> m_voxelBuffer;
vkcv::Image m_dummyRenderTarget;
vkcv::PassHandle m_voxelizationPass;
@@ -55,6 +67,9 @@ private:
vkcv::PassHandle m_visualisationPass;
vkcv::PipelineHandle m_visualisationPipe;
+ vkcv::PipelineHandle m_secondaryBouncePipe;
+ vkcv::DescriptorSetHandle m_secondaryBounceDescriptorSet;
+
vkcv::DescriptorSetHandle m_visualisationDescriptorSet;
struct VoxelizationInfo {
@@ -63,5 +78,5 @@ private:
};
vkcv::Buffer<VoxelizationInfo> m_voxelInfoBuffer;
- float m_voxelExtent = 20.f;
+ VoxelizationInfo m_voxelInfo;
};
\ No newline at end of file
diff --git a/projects/voxelization/src/main.cpp b/projects/voxelization/src/main.cpp
index aabed2180f598c9792a76ddcdcf4a2f400d16334..edc50c554b6c73bd2f06914eba6dd7adf9e43483 100644
--- a/projects/voxelization/src/main.cpp
+++ b/projects/voxelization/src/main.cpp
@@ -9,12 +9,16 @@
#include "Voxelization.hpp"
#include <glm/glm.hpp>
#include "vkcv/gui/GUI.hpp"
+#include "ShadowMapping.hpp"
+#include "BloomAndFlares.hpp"
int main(int argc, const char** argv) {
const char* applicationName = "Voxelization";
uint32_t windowWidth = 1280;
uint32_t windowHeight = 720;
+ const vkcv::Multisampling msaa = vkcv::Multisampling::MSAA4X;
+ const bool usingMsaa = msaa != vkcv::Multisampling::None;
vkcv::Window window = vkcv::Window::create(
applicationName,
@@ -23,13 +27,55 @@ int main(int argc, const char** argv) {
true
);
- vkcv::camera::CameraManager cameraManager(window);
- uint32_t camIndex = cameraManager.addCamera(vkcv::camera::ControllerType::PILOT);
- uint32_t camIndex2 = cameraManager.addCamera(vkcv::camera::ControllerType::TRACKBALL);
-
- cameraManager.getCamera(camIndex).setPosition(glm::vec3(0.f, 0.f, 3.f));
- cameraManager.getCamera(camIndex).setNearFar(0.1f, 30.0f);
+ bool isFullscreen = false;
+ int windowedWidthBackup = windowWidth;
+ int windowedHeightBackup = windowHeight;
+ int windowedPosXBackup;
+ int windowedPosYBackup;
+ glfwGetWindowPos(window.getWindow(), &windowedPosXBackup, &windowedPosYBackup);
+
+ window.e_key.add([&](int key, int scancode, int action, int mods) {
+ if (key == GLFW_KEY_F11 && action == GLFW_PRESS) {
+ if (isFullscreen) {
+ glfwSetWindowMonitor(
+ window.getWindow(),
+ nullptr,
+ windowedPosXBackup,
+ windowedPosYBackup,
+ windowedWidthBackup,
+ windowedHeightBackup,
+ GLFW_DONT_CARE);
+ }
+ else {
+ windowedWidthBackup = windowWidth;
+ windowedHeightBackup = windowHeight;
+
+ glfwGetWindowPos(window.getWindow(), &windowedPosXBackup, &windowedPosYBackup);
+
+ GLFWmonitor* monitor = glfwGetPrimaryMonitor();
+ const GLFWvidmode* videoMode = glfwGetVideoMode(monitor);
+
+ glfwSetWindowMonitor(
+ window.getWindow(),
+ glfwGetPrimaryMonitor(),
+ 0,
+ 0,
+ videoMode->width,
+ videoMode->height,
+ videoMode->refreshRate);
+ }
+ isFullscreen = !isFullscreen;
+ }
+ });
+
+ vkcv::camera::CameraManager cameraManager(window);
+ uint32_t camIndex = cameraManager.addCamera(vkcv::camera::ControllerType::PILOT);
+ uint32_t camIndex2 = cameraManager.addCamera(vkcv::camera::ControllerType::TRACKBALL);
+
+ cameraManager.getCamera(camIndex).setPosition(glm::vec3(0.f, 0.f, 3.f));
+ cameraManager.getCamera(camIndex).setNearFar(0.1f, 30.0f);
cameraManager.getCamera(camIndex).setYaw(180.0f);
+ cameraManager.getCamera(camIndex).setFov(glm::radians(37.8)); // fov of a 35mm lens
cameraManager.getCamera(camIndex2).setNearFar(0.1f, 30.0f);
@@ -114,11 +160,12 @@ int main(int argc, const char** argv) {
const vk::Format depthBufferFormat = vk::Format::eD32Sfloat;
const vkcv::AttachmentDescription depth_attachment(
vkcv::AttachmentOperation::STORE,
- vkcv::AttachmentOperation::CLEAR,
+ vkcv::AttachmentOperation::LOAD,
depthBufferFormat
);
-
- vkcv::PassConfig forwardPassDefinition({ color_attachment, depth_attachment });
+
+ // forward shading config
+ vkcv::PassConfig forwardPassDefinition({ color_attachment, depth_attachment }, msaa);
vkcv::PassHandle forwardPass = core.createPass(forwardPassDefinition);
vkcv::shader::GLSLCompiler compiler;
@@ -141,37 +188,37 @@ int main(int argc, const char** argv) {
}
const vkcv::VertexLayout vertexLayout (vertexBindings);
- // shadow map
- vkcv::SamplerHandle shadowSampler = core.createSampler(
- vkcv::SamplerFilterType::NEAREST,
- vkcv::SamplerFilterType::NEAREST,
- vkcv::SamplerMipmapMode::NEAREST,
- vkcv::SamplerAddressMode::CLAMP_TO_EDGE
- );
- const vk::Format shadowMapFormat = vk::Format::eD16Unorm;
- const uint32_t shadowMapResolution = 1024;
- const vkcv::Image shadowMap = core.createImage(shadowMapFormat, shadowMapResolution, shadowMapResolution);
-
- // light info buffer
- struct LightInfo {
- glm::vec3 direction;
- float padding;
- glm::vec3 sunColor = glm::vec3(1.f);
- float sunStrength = 8.f;
- glm::mat4 lightMatrix;
- };
- LightInfo lightInfo;
- vkcv::Buffer lightBuffer = core.createBuffer<LightInfo>(vkcv::BufferType::UNIFORM, sizeof(glm::vec3));
-
vkcv::DescriptorSetHandle forwardShadingDescriptorSet =
core.createDescriptorSet({ forwardProgram.getReflectedDescriptors()[0] });
- vkcv::DescriptorWrites forwardDescriptorWrites;
- forwardDescriptorWrites.uniformBufferWrites = { vkcv::UniformBufferDescriptorWrite(0, lightBuffer.getHandle()) };
- forwardDescriptorWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(1, shadowMap.getHandle()) };
- forwardDescriptorWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(2, shadowSampler) };
- core.writeDescriptorSet(forwardShadingDescriptorSet, forwardDescriptorWrites);
+ // depth prepass config
+ vkcv::ShaderProgram depthPrepassShader;
+ compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/depthPrepass.vert"),
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ depthPrepassShader.addShader(shaderStage, path);
+ });
+ compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/depthPrepass.frag"),
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ depthPrepassShader.addShader(shaderStage, path);
+ });
+
+ const std::vector<vkcv::VertexAttachment> prepassVertexAttachments = depthPrepassShader.getVertexAttachments();
+
+ std::vector<vkcv::VertexBinding> prepassVertexBindings;
+ for (size_t i = 0; i < prepassVertexAttachments.size(); i++) {
+ prepassVertexBindings.push_back(vkcv::VertexBinding(i, { prepassVertexAttachments[i] }));
+ }
+ const vkcv::VertexLayout prepassVertexLayout(prepassVertexBindings);
+
+ const vkcv::AttachmentDescription prepassAttachment(
+ vkcv::AttachmentOperation::STORE,
+ vkcv::AttachmentOperation::CLEAR,
+ depthBufferFormat);
+ vkcv::PassConfig prepassPassDefinition({ prepassAttachment }, msaa);
+ vkcv::PassHandle prepassPass = core.createPass(prepassPassDefinition);
+
+ // create descriptor sets
vkcv::SamplerHandle colorSampler = core.createSampler(
vkcv::SamplerFilterType::LINEAR,
vkcv::SamplerFilterType::LINEAR,
@@ -179,29 +226,59 @@ int main(int argc, const char** argv) {
vkcv::SamplerAddressMode::REPEAT
);
- // create descriptor sets
std::vector<vkcv::DescriptorSetHandle> materialDescriptorSets;
std::vector<vkcv::Image> sceneImages;
for (const auto& material : scene.materials) {
- int baseColorIndex = material.baseColor;
- if (baseColorIndex < 0) {
- vkcv_log(vkcv::LogLevel::WARNING, "Material lacks base color");
- baseColorIndex = 0;
+ int albedoIndex = material.baseColor;
+ int normalIndex = material.normal;
+ int specularIndex = material.metalRough;
+
+ if (albedoIndex < 0) {
+ vkcv_log(vkcv::LogLevel::WARNING, "Material lacks albedo");
+ albedoIndex = 0;
+ }
+ if (normalIndex < 0) {
+ vkcv_log(vkcv::LogLevel::WARNING, "Material lacks normal");
+ normalIndex = 0;
+ }
+ if (specularIndex < 0) {
+ vkcv_log(vkcv::LogLevel::WARNING, "Material lacks specular");
+ specularIndex = 0;
}
materialDescriptorSets.push_back(core.createDescriptorSet(forwardProgram.getReflectedDescriptors()[1]));
- vkcv::asset::Texture& sceneTexture = scene.textures[baseColorIndex];
+ vkcv::asset::Texture& albedoTexture = scene.textures[albedoIndex];
+ vkcv::asset::Texture& normalTexture = scene.textures[normalIndex];
+ vkcv::asset::Texture& specularTexture = scene.textures[specularIndex];
+
+ // albedo texture
+ sceneImages.push_back(core.createImage(vk::Format::eR8G8B8A8Srgb, albedoTexture.w, albedoTexture.h, 1, true));
+ sceneImages.back().fill(albedoTexture.data.data());
+ sceneImages.back().generateMipChainImmediate();
+ sceneImages.back().switchLayout(vk::ImageLayout::eShaderReadOnlyOptimal);
+ const vkcv::ImageHandle albedoHandle = sceneImages.back().getHandle();
+
+ // normal texture
+ sceneImages.push_back(core.createImage(vk::Format::eR8G8B8A8Unorm, normalTexture.w, normalTexture.h, 1, true));
+ sceneImages.back().fill(normalTexture.data.data());
+ sceneImages.back().generateMipChainImmediate();
+ sceneImages.back().switchLayout(vk::ImageLayout::eShaderReadOnlyOptimal);
+ const vkcv::ImageHandle normalHandle = sceneImages.back().getHandle();
- sceneImages.push_back(core.createImage(vk::Format::eR8G8B8A8Srgb, sceneTexture.w, sceneTexture.h, 1, true));
- sceneImages.back().fill(sceneTexture.data.data());
+ // specular texture
+ sceneImages.push_back(core.createImage(vk::Format::eR8G8B8A8Unorm, specularTexture.w, specularTexture.h, 1, true));
+ sceneImages.back().fill(specularTexture.data.data());
sceneImages.back().generateMipChainImmediate();
sceneImages.back().switchLayout(vk::ImageLayout::eShaderReadOnlyOptimal);
+ const vkcv::ImageHandle specularHandle = sceneImages.back().getHandle();
vkcv::DescriptorWrites setWrites;
setWrites.sampledImageWrites = {
- vkcv::SampledImageDescriptorWrite(0, sceneImages.back().getHandle())
+ vkcv::SampledImageDescriptorWrite(0, albedoHandle),
+ vkcv::SampledImageDescriptorWrite(2, normalHandle),
+ vkcv::SampledImageDescriptorWrite(3, specularHandle)
};
setWrites.samplerWrites = {
vkcv::SamplerDescriptorWrite(1, colorSampler),
@@ -214,16 +291,42 @@ int main(int argc, const char** argv) {
perMeshDescriptorSets.push_back(materialDescriptorSets[vertexGroup.materialIndex]);
}
- const vkcv::PipelineConfig forwardPipelineConfig {
+ // prepass pipeline
+ vkcv::DescriptorSetHandle prepassDescriptorSet = core.createDescriptorSet(std::vector<vkcv::DescriptorBinding>());
+
+ vkcv::PipelineConfig prepassPipelineConfig{
+ depthPrepassShader,
+ windowWidth,
+ windowHeight,
+ prepassPass,
+ vertexLayout,
+ {
+ core.getDescriptorSet(prepassDescriptorSet).layout,
+ core.getDescriptorSet(perMeshDescriptorSets[0]).layout },
+ true };
+ prepassPipelineConfig.m_culling = vkcv::CullMode::Back;
+ prepassPipelineConfig.m_multisampling = msaa;
+ prepassPipelineConfig.m_depthTest = vkcv::DepthTest::LessEqual;
+ prepassPipelineConfig.m_alphaToCoverage = true;
+
+ vkcv::PipelineHandle prepassPipeline = core.createGraphicsPipeline(prepassPipelineConfig);
+
+ // forward pipeline
+ vkcv::PipelineConfig forwardPipelineConfig {
forwardProgram,
windowWidth,
windowHeight,
forwardPass,
vertexLayout,
- { core.getDescriptorSet(forwardShadingDescriptorSet).layout,
+ {
+ core.getDescriptorSet(forwardShadingDescriptorSet).layout,
core.getDescriptorSet(perMeshDescriptorSets[0]).layout },
true
};
+ forwardPipelineConfig.m_culling = vkcv::CullMode::Back;
+ forwardPipelineConfig.m_multisampling = msaa;
+ forwardPipelineConfig.m_depthTest = vkcv::DepthTest::Equal;
+ forwardPipelineConfig.m_depthWrite = false;
vkcv::PipelineHandle forwardPipeline = core.createGraphicsPipeline(forwardPipelineConfig);
@@ -232,39 +335,66 @@ int main(int argc, const char** argv) {
return EXIT_FAILURE;
}
- vkcv::ImageHandle depthBuffer = core.createImage(depthBufferFormat, windowWidth, windowHeight).getHandle();
- vkcv::ImageHandle colorBuffer = core.createImage(colorBufferFormat, windowWidth, windowHeight, 1, false, true, true).getHandle();
+ // sky
+ struct SkySettings {
+ glm::vec3 color;
+ float strength;
+ };
+ SkySettings skySettings;
+ skySettings.color = glm::vec3(0.15, 0.65, 1);
+ skySettings.strength = 5;
- const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
+ const vkcv::AttachmentDescription skyColorAttachment(
+ vkcv::AttachmentOperation::STORE,
+ vkcv::AttachmentOperation::LOAD,
+ colorBufferFormat);
+
+ const vkcv::AttachmentDescription skyDepthAttachments(
+ vkcv::AttachmentOperation::STORE,
+ vkcv::AttachmentOperation::LOAD,
+ depthBufferFormat);
+
+ vkcv::PassConfig skyPassConfig({ skyColorAttachment, skyDepthAttachments }, msaa);
+ vkcv::PassHandle skyPass = core.createPass(skyPassConfig);
- vkcv::ShaderProgram shadowShader;
- compiler.compile(vkcv::ShaderStage::VERTEX, "resources/shaders/shadow.vert",
+ vkcv::ShaderProgram skyShader;
+ compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/sky.vert"),
[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
- shadowShader.addShader(shaderStage, path);
+ skyShader.addShader(shaderStage, path);
});
- compiler.compile(vkcv::ShaderStage::FRAGMENT, "resources/shaders/shadow.frag",
+ compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/sky.frag"),
[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
- shadowShader.addShader(shaderStage, path);
+ skyShader.addShader(shaderStage, path);
});
- const std::vector<vkcv::AttachmentDescription> shadowAttachments = {
- vkcv::AttachmentDescription(vkcv::AttachmentOperation::STORE, vkcv::AttachmentOperation::CLEAR, shadowMapFormat)
- };
- const vkcv::PassConfig shadowPassConfig(shadowAttachments);
- const vkcv::PassHandle shadowPass = core.createPass(shadowPassConfig);
- const vkcv::PipelineConfig shadowPipeConfig{
- shadowShader,
- shadowMapResolution,
- shadowMapResolution,
- shadowPass,
- vertexLayout,
- {},
- false
- };
- const vkcv::PipelineHandle shadowPipe = core.createGraphicsPipeline(shadowPipeConfig);
+ vkcv::PipelineConfig skyPipeConfig;
+ skyPipeConfig.m_ShaderProgram = skyShader;
+ skyPipeConfig.m_Width = windowWidth;
+ skyPipeConfig.m_Height = windowHeight;
+ skyPipeConfig.m_PassHandle = skyPass;
+ skyPipeConfig.m_VertexLayout = vkcv::VertexLayout();
+ skyPipeConfig.m_DescriptorLayouts = {};
+ skyPipeConfig.m_UseDynamicViewport = true;
+ skyPipeConfig.m_multisampling = msaa;
+ skyPipeConfig.m_depthWrite = false;
+
+ vkcv::PipelineHandle skyPipe = core.createGraphicsPipeline(skyPipeConfig);
+
+ // render targets
+ vkcv::ImageHandle depthBuffer = core.createImage(depthBufferFormat, windowWidth, windowHeight, 1, false, false, false, msaa).getHandle();
+
+ const bool colorBufferRequiresStorage = !usingMsaa;
+ vkcv::ImageHandle colorBuffer = core.createImage(colorBufferFormat, windowWidth, windowHeight, 1, false, colorBufferRequiresStorage, true, msaa).getHandle();
+
+ vkcv::ImageHandle resolvedColorBuffer;
+ if (usingMsaa) {
+ resolvedColorBuffer = core.createImage(colorBufferFormat, windowWidth, windowHeight, 1, false, true, true).getHandle();
+ }
+ else {
+ resolvedColorBuffer = colorBuffer;
+ }
- std::vector<std::array<glm::mat4, 2>> mainPassMatrices;
- std::vector<glm::mat4> mvpLight;
+ const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
bool renderVoxelVis = false;
window.e_key.add([&renderVoxelVis](int key ,int scancode, int action, int mods) {
@@ -273,16 +403,43 @@ int main(int argc, const char** argv) {
}
});
+ bool renderUI = true;
+ window.e_key.add([&renderUI](int key, int scancode, int action, int mods) {
+ if (key == GLFW_KEY_I && action == GLFW_PRESS) {
+ renderUI = !renderUI;
+ }
+ });
+
// tonemapping compute shader
vkcv::ShaderProgram tonemappingProgram;
compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/tonemapping.comp",
[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
tonemappingProgram.addShader(shaderStage, path);
});
- vkcv::DescriptorSetHandle tonemappingDescriptorSet = core.createDescriptorSet(tonemappingProgram.getReflectedDescriptors()[0]);
- vkcv::PipelineHandle tonemappingPipeline = core.createComputePipeline(tonemappingProgram,
+ vkcv::DescriptorSetHandle tonemappingDescriptorSet = core.createDescriptorSet(
+ tonemappingProgram.getReflectedDescriptors()[0]);
+ vkcv::PipelineHandle tonemappingPipeline = core.createComputePipeline(
+ tonemappingProgram,
{ core.getDescriptorSet(tonemappingDescriptorSet).layout });
+ // resolve compute shader
+ vkcv::ShaderProgram resolveProgram;
+ compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/msaa4XResolve.comp",
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ resolveProgram.addShader(shaderStage, path);
+ });
+ vkcv::DescriptorSetHandle resolveDescriptorSet = core.createDescriptorSet(
+ resolveProgram.getReflectedDescriptors()[0]);
+ vkcv::PipelineHandle resolvePipeline = core.createComputePipeline(
+ resolveProgram,
+ { core.getDescriptorSet(resolveDescriptorSet).layout });
+
+ vkcv::SamplerHandle resolveSampler = core.createSampler(
+ vkcv::SamplerFilterType::NEAREST,
+ vkcv::SamplerFilterType::NEAREST,
+ vkcv::SamplerMipmapMode::NEAREST,
+ vkcv::SamplerAddressMode::CLAMP_TO_EDGE);
+
// model matrices per mesh
std::vector<glm::mat4> modelMatrices;
modelMatrices.resize(scene.vertexGroups.size(), glm::mat4(1.f));
@@ -293,26 +450,33 @@ int main(int argc, const char** argv) {
}
}
- // prepare drawcalls
+ // prepare meshes
std::vector<vkcv::Mesh> meshes;
for (int i = 0; i < scene.vertexGroups.size(); i++) {
- vkcv::Mesh mesh(
- vertexBufferBindings[i],
- indexBuffers[i].getVulkanHandle(),
- scene.vertexGroups[i].numIndices);
+ vkcv::Mesh mesh(vertexBufferBindings[i], indexBuffers[i].getVulkanHandle(), scene.vertexGroups[i].numIndices);
meshes.push_back(mesh);
}
std::vector<vkcv::DrawcallInfo> drawcalls;
- std::vector<vkcv::DrawcallInfo> shadowDrawcalls;
+ std::vector<vkcv::DrawcallInfo> prepassDrawcalls;
for (int i = 0; i < meshes.size(); i++) {
drawcalls.push_back(vkcv::DrawcallInfo(meshes[i], {
vkcv::DescriptorSetUsage(0, core.getDescriptorSet(forwardShadingDescriptorSet).vulkanHandle),
vkcv::DescriptorSetUsage(1, core.getDescriptorSet(perMeshDescriptorSets[i]).vulkanHandle) }));
- shadowDrawcalls.push_back(vkcv::DrawcallInfo(meshes[i], {}));
+ prepassDrawcalls.push_back(vkcv::DrawcallInfo(meshes[i], {
+ vkcv::DescriptorSetUsage(0, core.getDescriptorSet(prepassDescriptorSet).vulkanHandle),
+ vkcv::DescriptorSetUsage(1, core.getDescriptorSet(perMeshDescriptorSets[i]).vulkanHandle) }));
}
+ vkcv::SamplerHandle voxelSampler = core.createSampler(
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::CLAMP_TO_EDGE);
+
+ ShadowMapping shadowMapping(&core, vertexLayout);
+
Voxelization::Dependencies voxelDependencies;
voxelDependencies.colorBufferFormat = colorBufferFormat;
voxelDependencies.depthBufferFormat = depthBufferFormat;
@@ -320,15 +484,62 @@ int main(int argc, const char** argv) {
Voxelization voxelization(
&core,
voxelDependencies,
- lightBuffer.getHandle(),
- shadowMap.getHandle(),
- shadowSampler);
+ shadowMapping.getLightInfoBuffer(),
+ shadowMapping.getShadowMap(),
+ shadowMapping.getShadowSampler(),
+ voxelSampler,
+ msaa);
+
+ BloomAndFlares bloomFlares(&core, colorBufferFormat, windowWidth, windowHeight);
+
+ window.e_key.add([&](int key, int scancode, int action, int mods) {
+ if (key == GLFW_KEY_R && action == GLFW_PRESS) {
+ bloomFlares = BloomAndFlares(&core, colorBufferFormat, windowWidth, windowHeight);
+ }
+ });
+
+ vkcv::Buffer<glm::vec3> cameraPosBuffer = core.createBuffer<glm::vec3>(vkcv::BufferType::UNIFORM, 1);
+
+ struct VolumetricSettings {
+ glm::vec3 scatteringCoefficient;
+ float ambientLight;
+ glm::vec3 absorptionCoefficient;
+ };
+ vkcv::Buffer<VolumetricSettings> volumetricSettingsBuffer
+ = core.createBuffer<VolumetricSettings>(vkcv::BufferType::UNIFORM ,1);
+
+ // write forward pass descriptor set
+ vkcv::DescriptorWrites forwardDescriptorWrites;
+ forwardDescriptorWrites.uniformBufferWrites = {
+ vkcv::UniformBufferDescriptorWrite(0, shadowMapping.getLightInfoBuffer()),
+ vkcv::UniformBufferDescriptorWrite(3, cameraPosBuffer.getHandle()),
+ vkcv::UniformBufferDescriptorWrite(6, voxelization.getVoxelInfoBufferHandle()),
+ vkcv::UniformBufferDescriptorWrite(7, volumetricSettingsBuffer.getHandle())};
+ forwardDescriptorWrites.sampledImageWrites = {
+ vkcv::SampledImageDescriptorWrite(1, shadowMapping.getShadowMap()),
+ vkcv::SampledImageDescriptorWrite(4, voxelization.getVoxelImageHandle()) };
+ forwardDescriptorWrites.samplerWrites = {
+ vkcv::SamplerDescriptorWrite(2, shadowMapping.getShadowSampler()),
+ vkcv::SamplerDescriptorWrite(5, voxelSampler) };
+ core.writeDescriptorSet(forwardShadingDescriptorSet, forwardDescriptorWrites);
vkcv::gui::GUI gui(core, window);
- glm::vec2 lightAngles(90.f, 0.f);
- int voxelVisualisationMip = 0;
- float voxelizationExtent = 20.f;
+ glm::vec2 lightAnglesDegree = glm::vec2(90.f, 0.f);
+ glm::vec3 lightColor = glm::vec3(1);
+ float lightStrength = 25.f;
+ float maxShadowDistance = 30.f;
+
+ int voxelVisualisationMip = 0;
+ float voxelizationExtent = 35.f;
+
+ bool msaaCustomResolve = true;
+
+ glm::vec3 scatteringColor = glm::vec3(1);
+ float scatteringDensity = 0.005;
+ glm::vec3 absorptionColor = glm::vec3(1);
+ float absorptionDensity = 0.005;
+ float volumetricAmbient = 0.2;
auto start = std::chrono::system_clock::now();
const auto appStartTime = start;
@@ -341,11 +552,20 @@ int main(int argc, const char** argv) {
}
if ((swapchainWidth != windowWidth) || ((swapchainHeight != windowHeight))) {
- depthBuffer = core.createImage(depthBufferFormat, swapchainWidth, swapchainHeight).getHandle();
- colorBuffer = core.createImage(colorBufferFormat, swapchainWidth, swapchainHeight, 1, false, true, true).getHandle();
+ depthBuffer = core.createImage(depthBufferFormat, swapchainWidth, swapchainHeight, 1, false, false, false, msaa).getHandle();
+ colorBuffer = core.createImage(colorBufferFormat, swapchainWidth, swapchainHeight, 1, false, colorBufferRequiresStorage, true, msaa).getHandle();
+
+ if (usingMsaa) {
+ resolvedColorBuffer = core.createImage(colorBufferFormat, swapchainWidth, swapchainHeight, 1, false, true, true).getHandle();
+ }
+ else {
+ resolvedColorBuffer = colorBuffer;
+ }
windowWidth = swapchainWidth;
windowHeight = swapchainHeight;
+
+ bloomFlares.updateImageDimensions(windowWidth, windowHeight);
}
auto end = std::chrono::system_clock::now();
@@ -353,78 +573,89 @@ int main(int argc, const char** argv) {
// update descriptor sets which use swapchain image
vkcv::DescriptorWrites tonemappingDescriptorWrites;
- tonemappingDescriptorWrites.storageImageWrites = {
- vkcv::StorageImageDescriptorWrite(0, colorBuffer),
- vkcv::StorageImageDescriptorWrite(1, swapchainInput) };
+ tonemappingDescriptorWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(0, resolvedColorBuffer) };
+ tonemappingDescriptorWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(1, colorSampler) };
+ tonemappingDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(2, swapchainInput) };
+
core.writeDescriptorSet(tonemappingDescriptorSet, tonemappingDescriptorWrites);
+ // update resolve descriptor, color images could be changed
+ vkcv::DescriptorWrites resolveDescriptorWrites;
+ resolveDescriptorWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(0, colorBuffer) };
+ resolveDescriptorWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(1, resolveSampler) };
+ resolveDescriptorWrites.storageImageWrites = { vkcv::StorageImageDescriptorWrite(2, resolvedColorBuffer) };
+ core.writeDescriptorSet(resolveDescriptorSet, resolveDescriptorWrites);
+
start = end;
cameraManager.update(0.000001 * static_cast<double>(deltatime.count()));
+ cameraPosBuffer.fill({ cameraManager.getActiveCamera().getPosition() });
- glm::vec2 lightAngleRadian = glm::radians(lightAngles);
- lightInfo.direction = glm::normalize(glm::vec3(
- std::cos(lightAngleRadian.x) * std::cos(lightAngleRadian.y),
- std::sin(lightAngleRadian.x),
- std::cos(lightAngleRadian.x) * std::sin(lightAngleRadian.y)));
-
- const float shadowProjectionSize = 20.f;
- glm::mat4 projectionLight = glm::ortho(
- -shadowProjectionSize,
- shadowProjectionSize,
- -shadowProjectionSize,
- shadowProjectionSize,
- -shadowProjectionSize,
- shadowProjectionSize);
+ auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
- glm::mat4 vulkanCorrectionMatrix(1.f);
- vulkanCorrectionMatrix[2][2] = 0.5;
- vulkanCorrectionMatrix[3][2] = 0.5;
- projectionLight = vulkanCorrectionMatrix * projectionLight;
+ voxelization.updateVoxelOffset(cameraManager.getActiveCamera());
- const glm::mat4 viewLight = glm::lookAt(glm::vec3(0), -lightInfo.direction, glm::vec3(0, -1, 0));
+ // shadow map
+ glm::vec2 lightAngleRadian = glm::radians(lightAnglesDegree);
+ shadowMapping.recordShadowMapRendering(
+ cmdStream,
+ lightAngleRadian,
+ lightColor,
+ lightStrength,
+ maxShadowDistance,
+ meshes,
+ modelMatrices,
+ cameraManager.getActiveCamera(),
+ voxelization.getVoxelOffset(),
+ voxelization.getVoxelExtent());
- lightInfo.lightMatrix = projectionLight * viewLight;
- lightBuffer.fill({ lightInfo });
+ // voxelization
+ voxelization.setVoxelExtent(voxelizationExtent);
+ voxelization.voxelizeMeshes(
+ cmdStream,
+ meshes,
+ modelMatrices,
+ perMeshDescriptorSets);
+ // depth prepass
const glm::mat4 viewProjectionCamera = cameraManager.getActiveCamera().getMVP();
- mainPassMatrices.clear();
- mvpLight.clear();
+ std::vector<glm::mat4> prepassMatrices;
for (const auto& m : modelMatrices) {
- mainPassMatrices.push_back({ viewProjectionCamera * m, m });
- mvpLight.push_back(lightInfo.lightMatrix * m);
+ prepassMatrices.push_back(viewProjectionCamera * m);
}
- vkcv::PushConstantData pushConstantData((void*)mainPassMatrices.data(), 2 * sizeof(glm::mat4));
- const std::vector<vkcv::ImageHandle> renderTargets = { colorBuffer, depthBuffer };
-
- const vkcv::PushConstantData shadowPushConstantData((void*)mvpLight.data(), sizeof(glm::mat4));
+ const vkcv::PushConstantData prepassPushConstantData((void*)prepassMatrices.data(), sizeof(glm::mat4));
+ const std::vector<vkcv::ImageHandle> prepassRenderTargets = { depthBuffer };
- auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
-
- // shadow map
core.recordDrawcallsToCmdStream(
cmdStream,
- shadowPass,
- shadowPipe,
- shadowPushConstantData,
- shadowDrawcalls,
- { shadowMap.getHandle() });
- core.prepareImageForSampling(cmdStream, shadowMap.getHandle());
+ prepassPass,
+ prepassPipeline,
+ prepassPushConstantData,
+ prepassDrawcalls,
+ prepassRenderTargets);
- voxelization.setVoxelExtent(voxelizationExtent);
- voxelization.voxelizeMeshes(
- cmdStream,
- cameraManager.getActiveCamera().getPosition(),
- meshes,
- modelMatrices,
- perMeshDescriptorSets);
+ core.recordImageMemoryBarrier(cmdStream, depthBuffer);
// main pass
+ std::vector<std::array<glm::mat4, 2>> mainPassMatrices;
+ for (const auto& m : modelMatrices) {
+ mainPassMatrices.push_back({ viewProjectionCamera * m, m });
+ }
+
+ VolumetricSettings volumeSettings;
+ volumeSettings.scatteringCoefficient = scatteringColor * scatteringDensity;
+ volumeSettings.absorptionCoefficient = absorptionColor * absorptionDensity;
+ volumeSettings.ambientLight = volumetricAmbient;
+ volumetricSettingsBuffer.fill({ volumeSettings });
+
+ const vkcv::PushConstantData pushConstantData((void*)mainPassMatrices.data(), 2 * sizeof(glm::mat4));
+ const std::vector<vkcv::ImageHandle> renderTargets = { colorBuffer, depthBuffer };
+
core.recordDrawcallsToCmdStream(
cmdStream,
- forwardPass,
- forwardPipeline,
+ forwardPass,
+ forwardPipeline,
pushConstantData,
drawcalls,
renderTargets);
@@ -433,38 +664,127 @@ int main(int argc, const char** argv) {
voxelization.renderVoxelVisualisation(cmdStream, viewProjectionCamera, renderTargets, voxelVisualisationMip);
}
- const uint32_t tonemappingLocalGroupSize = 8;
- const uint32_t tonemappingDispatchCount[3] = {
- static_cast<uint32_t>(glm::ceil(windowWidth / static_cast<float>(tonemappingLocalGroupSize))),
- static_cast<uint32_t>(glm::ceil(windowHeight / static_cast<float>(tonemappingLocalGroupSize))),
+ // sky
+ core.recordDrawcallsToCmdStream(
+ cmdStream,
+ skyPass,
+ skyPipe,
+ vkcv::PushConstantData((void*)&skySettings, sizeof(skySettings)),
+ { vkcv::DrawcallInfo(vkcv::Mesh({}, nullptr, 3), {}) },
+ renderTargets);
+
+ const uint32_t fullscreenLocalGroupSize = 8;
+ const uint32_t fulsscreenDispatchCount[3] = {
+ static_cast<uint32_t>(glm::ceil(windowWidth / static_cast<float>(fullscreenLocalGroupSize))),
+ static_cast<uint32_t>(glm::ceil(windowHeight / static_cast<float>(fullscreenLocalGroupSize))),
1
};
+ if (usingMsaa) {
+ if (msaaCustomResolve) {
+
+ core.prepareImageForSampling(cmdStream, colorBuffer);
+ core.prepareImageForStorage(cmdStream, resolvedColorBuffer);
+
+ assert(msaa == vkcv::Multisampling::MSAA4X); // shaders is written for msaa 4x
+ core.recordComputeDispatchToCmdStream(
+ cmdStream,
+ resolvePipeline,
+ fulsscreenDispatchCount,
+ { vkcv::DescriptorSetUsage(0, core.getDescriptorSet(resolveDescriptorSet).vulkanHandle) },
+ vkcv::PushConstantData(nullptr, 0));
+
+ core.recordImageMemoryBarrier(cmdStream, resolvedColorBuffer);
+ }
+ else {
+ core.resolveMSAAImage(cmdStream, colorBuffer, resolvedColorBuffer);
+ }
+ }
+
+ bloomFlares.execWholePipeline(cmdStream, resolvedColorBuffer, windowWidth, windowHeight,
+ glm::normalize(cameraManager.getActiveCamera().getFront()));
+
core.prepareImageForStorage(cmdStream, swapchainInput);
- core.prepareImageForStorage(cmdStream, colorBuffer);
+ core.prepareImageForSampling(cmdStream, resolvedColorBuffer);
+
+ auto timeSinceStart = std::chrono::duration_cast<std::chrono::microseconds>(end - appStartTime);
+ float timeF = static_cast<float>(timeSinceStart.count()) * 0.01;
core.recordComputeDispatchToCmdStream(
cmdStream,
tonemappingPipeline,
- tonemappingDispatchCount,
+ fulsscreenDispatchCount,
{ vkcv::DescriptorSetUsage(0, core.getDescriptorSet(tonemappingDescriptorSet).vulkanHandle) },
- vkcv::PushConstantData(nullptr, 0));
+ vkcv::PushConstantData(&timeF, sizeof(timeF)));
// present and end
core.prepareSwapchainImageForPresent(cmdStream);
core.submitCommandStream(cmdStream);
+ // draw UI
gui.beginGUI();
- ImGui::Begin("Settings");
- ImGui::DragFloat2("Light angles", &lightAngles.x);
- ImGui::ColorEdit3("Sun color", &lightInfo.sunColor.x);
- ImGui::DragFloat("Sun strength", &lightInfo.sunStrength);
- ImGui::Checkbox("Draw voxel visualisation", &renderVoxelVis);
- ImGui::SliderInt("Visualisation mip", &voxelVisualisationMip, 0, 7);
- ImGui::DragFloat("Voxelization extent", &voxelizationExtent, 1.f, 0.f);
- voxelVisualisationMip = std::max(voxelVisualisationMip, 0);
- ImGui::End();
+ if (renderUI) {
+ ImGui::Begin("Settings");
+
+ ImGui::Checkbox("MSAA custom resolve", &msaaCustomResolve);
+
+ ImGui::DragFloat2("Light angles", &lightAnglesDegree.x);
+ ImGui::ColorEdit3("Sun color", &lightColor.x);
+ ImGui::DragFloat("Sun strength", &lightStrength);
+ ImGui::DragFloat("Max shadow distance", &maxShadowDistance);
+ maxShadowDistance = std::max(maxShadowDistance, 1.f);
+
+ ImGui::ColorEdit3("Sky color", &skySettings.color.x);
+ ImGui::DragFloat("Sky strength", &skySettings.strength, 0.1);
+
+ ImGui::Checkbox("Draw voxel visualisation", &renderVoxelVis);
+ ImGui::SliderInt("Visualisation mip", &voxelVisualisationMip, 0, 7);
+ ImGui::DragFloat("Voxelization extent", &voxelizationExtent, 1.f, 0.f);
+ voxelizationExtent = std::max(voxelizationExtent, 1.f);
+ voxelVisualisationMip = std::max(voxelVisualisationMip, 0);
+
+ ImGui::ColorEdit3("Scattering color", &scatteringColor.x);
+ ImGui::DragFloat("Scattering density", &scatteringDensity, 0.0001);
+ ImGui::ColorEdit3("Absorption color", &absorptionColor.x);
+ ImGui::DragFloat("Absorption density", &absorptionDensity, 0.0001);
+ ImGui::DragFloat("Volumetric ambient", &volumetricAmbient, 0.002);
+
+ if (ImGui::Button("Reload forward pass")) {
+
+ vkcv::ShaderProgram newForwardProgram;
+ compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/shader.vert"),
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ newForwardProgram.addShader(shaderStage, path);
+ });
+ compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/shader.frag"),
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ newForwardProgram.addShader(shaderStage, path);
+ });
+ forwardPipelineConfig.m_ShaderProgram = newForwardProgram;
+ vkcv::PipelineHandle newPipeline = core.createGraphicsPipeline(forwardPipelineConfig);
+
+ if (newPipeline) {
+ forwardPipeline = newPipeline;
+ }
+ }
+ if (ImGui::Button("Reload tonemapping")) {
+
+ vkcv::ShaderProgram newProgram;
+ compiler.compile(vkcv::ShaderStage::COMPUTE, std::filesystem::path("resources/shaders/tonemapping.comp"),
+ [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ newProgram.addShader(shaderStage, path);
+ });
+ vkcv::PipelineHandle newPipeline = core.createComputePipeline(
+ newProgram,
+ { core.getDescriptorSet(tonemappingDescriptorSet).layout });
+
+ if (newPipeline) {
+ tonemappingPipeline = newPipeline;
+ }
+ }
+ ImGui::End();
+ }
gui.endGUI();
diff --git a/src/vkcv/Context.cpp b/src/vkcv/Context.cpp
index ac133d1affc81702ee1a19b3f66810e606bec58d..e23213b41a3c9a289b679652b66bbe2e75cf0340 100644
--- a/src/vkcv/Context.cpp
+++ b/src/vkcv/Context.cpp
@@ -280,6 +280,7 @@ namespace vkcv
vk::PhysicalDeviceFeatures deviceFeatures;
deviceFeatures.fragmentStoresAndAtomics = true;
deviceFeatures.geometryShader = true;
+ deviceFeatures.depthClamp = true;
deviceCreateInfo.pEnabledFeatures = &deviceFeatures;
// Ablauf
diff --git a/src/vkcv/Core.cpp b/src/vkcv/Core.cpp
index 59f2cf3b652a88854b9ea4a4077f18749b9e6d51..352a1cf62eabe55ce1bbf2f53a6b5a4bd6e91753 100644
--- a/src/vkcv/Core.cpp
+++ b/src/vkcv/Core.cpp
@@ -20,6 +20,35 @@
namespace vkcv
{
+
+ static std::vector<vk::ImageView> createSwapchainImageViews( Context &context, const std::vector<vk::Image>& images,
+ vk::Format format){
+ std::vector<vk::ImageView> imageViews;
+ imageViews.reserve( images.size() );
+ //here can be swizzled with vk::ComponentSwizzle if needed
+ vk::ComponentMapping componentMapping(
+ vk::ComponentSwizzle::eR,
+ vk::ComponentSwizzle::eG,
+ vk::ComponentSwizzle::eB,
+ vk::ComponentSwizzle::eA );
+
+ vk::ImageSubresourceRange subResourceRange( vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1 );
+
+ for ( auto image : images )
+ {
+ vk::ImageViewCreateInfo imageViewCreateInfo(
+ vk::ImageViewCreateFlags(),
+ image,
+ vk::ImageViewType::e2D,
+ format,
+ componentMapping,
+ subResourceRange);
+
+ imageViews.push_back(context.getDevice().createImageView(imageViewCreateInfo));
+ }
+
+ return imageViews;
+ }
Core Core::create(Window &window,
const char *applicationName,
@@ -36,8 +65,9 @@ namespace vkcv
);
Swapchain swapChain = Swapchain::create(window, context);
-
- std::vector<vk::ImageView> swapchainImageViews = createSwapchainImageViews( context, swapChain);
+
+ const auto swapchainImages = context.getDevice().getSwapchainImagesKHR(swapChain.getSwapchain());
+ const auto swapchainImageViews = createSwapchainImageViews( context, swapchainImages, swapChain.getFormat());
const auto& queueManager = context.getQueueManager();
@@ -116,7 +146,6 @@ namespace vkcv
return m_PipelineManager->createComputePipeline(shaderProgram, descriptorSetLayouts);
}
-
PassHandle Core::createPass(const PassConfig &config)
{
return m_PassManager->createPass(config);
@@ -124,7 +153,6 @@ namespace vkcv
Result Core::acquireSwapchainImage() {
uint32_t imageIndex;
-
vk::Result result;
try {
@@ -137,11 +165,18 @@ namespace vkcv
);
} catch (vk::OutOfDateKHRError e) {
result = vk::Result::eErrorOutOfDateKHR;
+ } catch (vk::DeviceLostError e) {
+ result = vk::Result::eErrorDeviceLost;
}
- if (result != vk::Result::eSuccess) {
+ if ((result != vk::Result::eSuccess) &&
+ (result != vk::Result::eSuboptimalKHR)) {
vkcv_log(LogLevel::ERROR, "%s", vk::to_string(result).c_str());
return Result::ERROR;
+ } else
+ if (result == vk::Result::eSuboptimalKHR) {
+ vkcv_log(LogLevel::WARNING, "Acquired image is suboptimal");
+ m_swapchain.signalSwapchainRecreation();
}
m_currentSwapchainImageIndex = imageIndex;
@@ -153,10 +188,31 @@ namespace vkcv
m_Context.getDevice().waitIdle();
m_swapchain.updateSwapchain(m_Context, m_window);
- const auto swapchainViews = createSwapchainImageViews(m_Context, m_swapchain);
+
+ if (!m_swapchain.getSwapchain()) {
+ return false;
+ }
+
const auto swapchainImages = m_Context.getDevice().getSwapchainImagesKHR(m_swapchain.getSwapchain());
-
- m_ImageManager->setSwapchainImages(swapchainImages, swapchainViews, width, height, m_swapchain.getFormat());
+ const auto swapchainViews = createSwapchainImageViews(m_Context, swapchainImages, m_swapchain.getFormat());
+
+ const auto& extent = m_swapchain.getExtent();
+
+ m_ImageManager->setSwapchainImages(
+ swapchainImages,
+ swapchainViews,
+ extent.width, extent.height,
+ m_swapchain.getFormat()
+ );
+ }
+
+ const auto& extent = m_swapchain.getExtent();
+
+ width = extent.width;
+ height = extent.height;
+
+ if ((width < MIN_SWAPCHAIN_SIZE) || (height < MIN_SWAPCHAIN_SIZE)) {
+ return false;
}
if (acquireSwapchainImage() != Result::SUCCESS) {
@@ -167,11 +223,6 @@ namespace vkcv
m_Context.getDevice().waitIdle(); // TODO: this is a sin against graphics programming, but its getting late - Alex
- const auto& extent = m_swapchain.getExtent();
-
- width = extent.width;
- height = extent.height;
-
m_ImageManager->setCurrentSwapchainImageIndex(m_currentSwapchainImageIndex);
return (m_currentSwapchainImageIndex != std::numeric_limits<uint32_t>::max());
@@ -368,10 +419,17 @@ namespace vkcv
result = queueManager.getPresentQueue().handle.presentKHR(presentInfo);
} catch (vk::OutOfDateKHRError e) {
result = vk::Result::eErrorOutOfDateKHR;
+ } catch (vk::DeviceLostError e) {
+ result = vk::Result::eErrorDeviceLost;
}
- if (result != vk::Result::eSuccess) {
- vkcv_log(LogLevel::ERROR, "Swapchain present failed (%s)", vk::to_string(result).c_str());
+ if ((result != vk::Result::eSuccess) &&
+ (result != vk::Result::eSuboptimalKHR)) {
+ vkcv_log(LogLevel::ERROR, "Swapchain presentation failed (%s)", vk::to_string(result).c_str());
+ } else
+ if (result == vk::Result::eSuboptimalKHR) {
+ vkcv_log(LogLevel::WARNING, "Swapchain presentation is suboptimal");
+ m_swapchain.signalSwapchainRecreation();
}
}
@@ -437,13 +495,14 @@ namespace vkcv
}
Image Core::createImage(
- vk::Format format,
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- bool createMipChain,
- bool supportStorage,
- bool supportColorAttachment)
+ vk::Format format,
+ uint32_t width,
+ uint32_t height,
+ uint32_t depth,
+ bool createMipChain,
+ bool supportStorage,
+ bool supportColorAttachment,
+ Multisampling multisampling)
{
uint32_t mipCount = 1;
@@ -459,7 +518,8 @@ namespace vkcv
depth,
mipCount,
supportStorage,
- supportColorAttachment);
+ supportColorAttachment,
+ multisampling);
}
const uint32_t Core::getImageWidth(ImageHandle imageHandle)
@@ -490,34 +550,6 @@ namespace vkcv
return m_DescriptorManager->getDescriptorSet(handle);
}
- std::vector<vk::ImageView> Core::createSwapchainImageViews( Context &context, Swapchain& swapChain){
- std::vector<vk::ImageView> imageViews;
- std::vector<vk::Image> swapChainImages = context.getDevice().getSwapchainImagesKHR(swapChain.getSwapchain());
- imageViews.reserve( swapChainImages.size() );
- //here can be swizzled with vk::ComponentSwizzle if needed
- vk::ComponentMapping componentMapping(
- vk::ComponentSwizzle::eR,
- vk::ComponentSwizzle::eG,
- vk::ComponentSwizzle::eB,
- vk::ComponentSwizzle::eA );
-
- vk::ImageSubresourceRange subResourceRange( vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1 );
-
- for ( auto image : swapChainImages )
- {
- vk::ImageViewCreateInfo imageViewCreateInfo(
- vk::ImageViewCreateFlags(),
- image,
- vk::ImageViewType::e2D,
- swapChain.getFormat(),
- componentMapping,
- subResourceRange);
-
- imageViews.push_back(context.getDevice().createImageView(imageViewCreateInfo));
- }
- return imageViews;
- }
-
void Core::prepareSwapchainImageForPresent(const CommandStreamHandle cmdStream) {
auto swapchainHandle = ImageHandle::createSwapchainImageHandle();
recordCommandsToStream(cmdStream, [swapchainHandle, this](const vk::CommandBuffer cmdBuffer) {
@@ -549,6 +581,12 @@ namespace vkcv
}, nullptr);
}
+ void Core::resolveMSAAImage(CommandStreamHandle cmdStream, ImageHandle src, ImageHandle dst) {
+ recordCommandsToStream(cmdStream, [src, dst, this](const vk::CommandBuffer cmdBuffer) {
+ m_ImageManager->recordMSAAResolve(cmdBuffer, src, dst);
+ }, nullptr);
+ }
+
vk::ImageView Core::getSwapchainImageView() const {
return m_ImageManager->getVulkanImageView(vkcv::ImageHandle::createSwapchainImageHandle());
}
diff --git a/src/vkcv/DrawcallRecording.cpp b/src/vkcv/DrawcallRecording.cpp
index df7b7bbcb3fe278622cd160593eb750db00ec7b1..e6ea18588c251b5e49f454618a5ac9962cc8a264 100644
--- a/src/vkcv/DrawcallRecording.cpp
+++ b/src/vkcv/DrawcallRecording.cpp
@@ -27,19 +27,21 @@ namespace vkcv {
// char* cast because void* does not support pointer arithmetic
const void* drawcallPushConstantData = drawcallPushConstantOffset + (char*)pushConstantData.data;
- cmdBuffer.pushConstants(
- pipelineLayout,
- vk::ShaderStageFlagBits::eAll,
- 0,
- pushConstantData.sizePerDrawcall,
- drawcallPushConstantData);
+ if (pushConstantData.data && pushConstantData.sizePerDrawcall > 0) {
+ cmdBuffer.pushConstants(
+ pipelineLayout,
+ vk::ShaderStageFlagBits::eAll,
+ 0,
+ pushConstantData.sizePerDrawcall,
+ drawcallPushConstantData);
+ }
if (drawcall.mesh.indexBuffer) {
cmdBuffer.bindIndexBuffer(drawcall.mesh.indexBuffer, 0, vk::IndexType::eUint16); //FIXME: choose proper size
- cmdBuffer.drawIndexed(drawcall.mesh.indexCount, 1, 0, 0, {});
+ cmdBuffer.drawIndexed(drawcall.mesh.indexCount, drawcall.instanceCount, 0, 0, {});
}
else {
cmdBuffer.draw(drawcall.mesh.indexCount, 1, 0, 0, {});
}
}
-}
\ No newline at end of file
+}
diff --git a/src/vkcv/Image.cpp b/src/vkcv/Image.cpp
index c48b015335e00f23a892bb96d3e89a2c0877ae61..f8d94b734599cbf1f55aad7b590ab4796501d951 100644
--- a/src/vkcv/Image.cpp
+++ b/src/vkcv/Image.cpp
@@ -27,9 +27,12 @@ namespace vkcv{
uint32_t depth,
uint32_t mipCount,
bool supportStorage,
- bool supportColorAttachment)
+ bool supportColorAttachment,
+ Multisampling msaa)
{
- return Image(manager, manager->createImage(width, height, depth, format, mipCount, supportStorage, supportColorAttachment));
+ return Image(
+ manager,
+ manager->createImage(width, height, depth, format, mipCount, supportStorage, supportColorAttachment, msaa));
}
vk::Format Image::getFormat() const {
diff --git a/src/vkcv/ImageConfig.cpp b/src/vkcv/ImageConfig.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..80aeac3d0f702467c8edc1b0f7378d0d7f15b3db
--- /dev/null
+++ b/src/vkcv/ImageConfig.cpp
@@ -0,0 +1,24 @@
+#include <vkcv/ImageConfig.hpp>
+#include <vkcv/Logger.hpp>
+
+namespace vkcv {
+ vk::SampleCountFlagBits msaaToVkSampleCountFlag(Multisampling msaa) {
+ switch (msaa) {
+ case Multisampling::None: return vk::SampleCountFlagBits::e1;
+ case Multisampling::MSAA2X: return vk::SampleCountFlagBits::e2;
+ case Multisampling::MSAA4X: return vk::SampleCountFlagBits::e4;
+ case Multisampling::MSAA8X: return vk::SampleCountFlagBits::e8;
+ default: vkcv_log(vkcv::LogLevel::ERROR, "Unknown Multisampling enum setting"); return vk::SampleCountFlagBits::e1;
+ }
+ }
+
+ uint32_t msaaToSampleCount(Multisampling msaa) {
+ switch (msaa) {
+ case Multisampling::None: return 1;
+ case Multisampling::MSAA2X: return 2;
+ case Multisampling::MSAA4X: return 4;
+ case Multisampling::MSAA8X: return 8;
+ default: vkcv_log(vkcv::LogLevel::ERROR, "Unknown Multisampling enum setting"); return 1;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/vkcv/ImageManager.cpp b/src/vkcv/ImageManager.cpp
index a3364ce0dfd6f59dc78c85b43570eea25cfc052d..ae554e6babdd2b2f42c352515c02a34e45182fec 100644
--- a/src/vkcv/ImageManager.cpp
+++ b/src/vkcv/ImageManager.cpp
@@ -85,13 +85,14 @@ namespace vkcv {
}
ImageHandle ImageManager::createImage(
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- vk::Format format,
- uint32_t mipCount,
- bool supportStorage,
- bool supportColorAttachment)
+ uint32_t width,
+ uint32_t height,
+ uint32_t depth,
+ vk::Format format,
+ uint32_t mipCount,
+ bool supportStorage,
+ bool supportColorAttachment,
+ Multisampling msaa)
{
const vk::PhysicalDevice& physicalDevice = m_core->getContext().getPhysicalDevice();
@@ -101,9 +102,17 @@ namespace vkcv {
vk::ImageUsageFlags imageUsageFlags = (
vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eTransferSrc
);
+
+ vk::ImageTiling imageTiling = vk::ImageTiling::eOptimal;
+
if (supportStorage) {
imageUsageFlags |= vk::ImageUsageFlagBits::eStorage;
+
+ if (!(formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eStorageImage)) {
+ imageTiling = vk::ImageTiling::eLinear;
+ }
}
+
if (supportColorAttachment) {
imageUsageFlags |= vk::ImageUsageFlagBits::eColorAttachment;
}
@@ -134,8 +143,6 @@ namespace vkcv {
imageViewType = vk::ImageViewType::e2D;
}
- vk::ImageTiling imageTiling = vk::ImageTiling::eOptimal;
-
if (!formatProperties.optimalTilingFeatures) {
if (!formatProperties.linearTilingFeatures)
return ImageHandle();
@@ -147,7 +154,9 @@ namespace vkcv {
physicalDevice.getImageFormatProperties(format, imageType, imageTiling, imageUsageFlags);
const uint32_t arrayLayers = std::min<uint32_t>(1, imageFormatProperties.maxArrayLayers);
-
+
+ vk::SampleCountFlagBits sampleCountFlag = msaaToVkSampleCountFlag(msaa);
+
const vk::ImageCreateInfo imageCreateInfo(
createFlags,
imageType,
@@ -155,7 +164,7 @@ namespace vkcv {
vk::Extent3D(width, height, depth),
mipCount,
arrayLayers,
- vk::SampleCountFlagBits::e1,
+ sampleCountFlag,
imageTiling,
imageUsageFlags,
vk::SharingMode::eExclusive,
@@ -269,7 +278,7 @@ namespace vkcv {
const auto& image = m_images[id];
- if (mipLevel >= m_images.size()) {
+ if (mipLevel >= image.m_viewPerMip.size()) {
vkcv_log(LogLevel::ERROR, "Image does not have requested mipLevel");
return nullptr;
}
@@ -352,8 +361,10 @@ namespace vkcv {
return 1;
case vk::Format::eR8G8B8A8Srgb:
return 4;
+ case vk::Format::eR8G8B8A8Unorm:
+ return 4;
default:
- std::cerr << "Check format instead of guessing, please!" << std::endl;
+ std::cerr << "Unknown image format" << std::endl;
return 4;
}
}
@@ -521,6 +532,43 @@ namespace vkcv {
m_core->recordCommandsToStream(cmdStream, record, nullptr);
}
+ void ImageManager::recordMSAAResolve(vk::CommandBuffer cmdBuffer, ImageHandle src, ImageHandle dst) {
+
+ const uint64_t srcId = src.getId();
+ const uint64_t dstId = dst.getId();
+
+ const bool isSrcSwapchainImage = src.isSwapchainImage();
+ const bool isDstSwapchainImage = dst.isSwapchainImage();
+
+ const bool isSrcHandleInvalid = srcId >= m_images.size() && !isSrcSwapchainImage;
+ const bool isDstHandleInvalid = dstId >= m_images.size() && !isDstSwapchainImage;
+
+ if (isSrcHandleInvalid || isDstHandleInvalid) {
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
+ return;
+ }
+
+ auto& srcImage = isSrcSwapchainImage ? m_swapchainImages[m_currentSwapchainInputImage] : m_images[srcId];
+ auto& dstImage = isDstSwapchainImage ? m_swapchainImages[m_currentSwapchainInputImage] : m_images[dstId];
+
+ vk::ImageResolve region(
+ vk::ImageSubresourceLayers(vk::ImageAspectFlagBits::eColor, 0, 0, 1),
+ vk::Offset3D(0, 0, 0),
+ vk::ImageSubresourceLayers(vk::ImageAspectFlagBits::eColor, 0, 0, 1),
+ vk::Offset3D(0, 0, 0),
+ vk::Extent3D(dstImage.m_width, dstImage.m_height, dstImage.m_depth));
+
+ recordImageLayoutTransition(src, vk::ImageLayout::eTransferSrcOptimal, cmdBuffer);
+ recordImageLayoutTransition(dst, vk::ImageLayout::eTransferDstOptimal, cmdBuffer);
+
+ cmdBuffer.resolveImage(
+ srcImage.m_handle,
+ srcImage.m_layout,
+ dstImage.m_handle,
+ dstImage.m_layout,
+ region);
+ }
+
uint32_t ImageManager::getImageWidth(const ImageHandle &handle) const {
const uint64_t id = handle.getId();
const bool isSwapchainImage = handle.isSwapchainImage();
diff --git a/src/vkcv/ImageManager.hpp b/src/vkcv/ImageManager.hpp
index ecba7eb5959c1d78a0be41e0b3ac555bffd92d95..1d8ce207b645e30cee291816eac3c934ed40e92a 100644
--- a/src/vkcv/ImageManager.hpp
+++ b/src/vkcv/ImageManager.hpp
@@ -9,6 +9,7 @@
#include "vkcv/BufferManager.hpp"
#include "vkcv/Handles.hpp"
+#include "vkcv/ImageConfig.hpp"
namespace vkcv {
@@ -72,13 +73,14 @@ namespace vkcv {
ImageManager& operator=(const ImageManager& other) = delete;
ImageHandle createImage(
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- vk::Format format,
- uint32_t mipCount,
- bool supportStorage,
- bool supportColorAttachment);
+ uint32_t width,
+ uint32_t height,
+ uint32_t depth,
+ vk::Format format,
+ uint32_t mipCount,
+ bool supportStorage,
+ bool supportColorAttachment,
+ Multisampling msaa);
ImageHandle createSwapchainImage();
@@ -104,7 +106,8 @@ namespace vkcv {
void fillImage(const ImageHandle& handle, void* data, size_t size);
void generateImageMipChainImmediate(const ImageHandle& handle);
void recordImageMipChainGenerationToCmdStream(const vkcv::CommandStreamHandle& cmdStream, const ImageHandle& handle);
-
+ void recordMSAAResolve(vk::CommandBuffer cmdBuffer, ImageHandle src, ImageHandle dst);
+
[[nodiscard]]
uint32_t getImageWidth(const ImageHandle& handle) const;
diff --git a/src/vkcv/PassConfig.cpp b/src/vkcv/PassConfig.cpp
index 602f1d3e2a8100ebd9bbb83772312d3d659abe86..78bd5808b63fee7333243db4fca640047f76eae9 100644
--- a/src/vkcv/PassConfig.cpp
+++ b/src/vkcv/PassConfig.cpp
@@ -13,7 +13,7 @@ namespace vkcv
format(format)
{};
- PassConfig::PassConfig(std::vector<AttachmentDescription> attachments) noexcept :
- attachments{std::move(attachments)}
+ PassConfig::PassConfig(std::vector<AttachmentDescription> attachments, Multisampling msaa) noexcept :
+ attachments{std::move(attachments) }, msaa(msaa)
{}
}
\ No newline at end of file
diff --git a/src/vkcv/PassManager.cpp b/src/vkcv/PassManager.cpp
index c34b0d3631c48561f42eb7f21ba5578156910f51..e50f800a482460cdb81687c76f8b1318598f689c 100644
--- a/src/vkcv/PassManager.cpp
+++ b/src/vkcv/PassManager.cpp
@@ -94,7 +94,7 @@ namespace vkcv
vk::AttachmentDescription attachmentDesc(
{},
format,
- vk::SampleCountFlagBits::e1,
+ msaaToVkSampleCountFlag(config.msaa),
getVKLoadOpFromAttachOp(config.attachments[i].load_operation),
getVkStoreOpFromAttachOp(config.attachments[i].store_operation),
vk::AttachmentLoadOp::eDontCare,
diff --git a/src/vkcv/PipelineManager.cpp b/src/vkcv/PipelineManager.cpp
index df36442efc2992bf16b6e82245ef9753dad95e5d..8b1f0b68be3a72f60103ca0dd8136f2c923513a5 100644
--- a/src/vkcv/PipelineManager.cpp
+++ b/src/vkcv/PipelineManager.cpp
@@ -51,6 +51,18 @@ namespace vkcv
}
}
+ vk::CompareOp depthTestToVkCompareOp(DepthTest depthTest) {
+ switch (depthTest) {
+ case(DepthTest::None): return vk::CompareOp::eAlways;
+ case(DepthTest::Less): return vk::CompareOp::eLess;
+ case(DepthTest::LessEqual): return vk::CompareOp::eLessOrEqual;
+ case(DepthTest::Greater): return vk::CompareOp::eGreater;
+ case(DepthTest::GreatherEqual): return vk::CompareOp::eGreaterOrEqual;
+ case(DepthTest::Equal): return vk::CompareOp::eEqual;
+ default: vkcv_log(vkcv::LogLevel::ERROR, "Unknown depth test enum"); return vk::CompareOp::eAlways;
+ }
+ }
+
PipelineHandle PipelineManager::createPipeline(const PipelineConfig &config, PassManager& passManager)
{
const vk::RenderPass &pass = passManager.getVkPass(config.m_PassHandle);
@@ -143,13 +155,21 @@ namespace vkcv
vk::Rect2D scissor({ 0,0 }, { config.m_Width, config.m_Height });
vk::PipelineViewportStateCreateInfo pipelineViewportStateCreateInfo({}, 1, &viewport, 1, &scissor);
+ vk::CullModeFlags cullMode;
+ switch (config.m_culling) {
+ case CullMode::None: cullMode = vk::CullModeFlagBits::eNone; break;
+ case CullMode::Front: cullMode = vk::CullModeFlagBits::eFront; break;
+ case CullMode::Back: cullMode = vk::CullModeFlagBits::eBack; break;
+ default: vkcv_log(vkcv::LogLevel::ERROR, "Unknown CullMode"); cullMode = vk::CullModeFlagBits::eNone;
+ }
+
// rasterization state
vk::PipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo(
{},
- false,
+ config.m_EnableDepthClamping,
false,
vk::PolygonMode::eFill,
- vk::CullModeFlagBits::eNone,
+ cullMode,
vk::FrontFace::eCounterClockwise,
false,
0.f,
@@ -169,11 +189,11 @@ namespace vkcv
// multisample state
vk::PipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo(
{},
- vk::SampleCountFlagBits::e1,
+ msaaToVkSampleCountFlag(config.m_multisampling),
false,
0.f,
nullptr,
- false,
+ config.m_alphaToCoverage,
false
);
@@ -182,8 +202,11 @@ namespace vkcv
VK_COLOR_COMPONENT_G_BIT |
VK_COLOR_COMPONENT_B_BIT |
VK_COLOR_COMPONENT_A_BIT);
+
+ // currently set to additive, if not disabled
+ // BlendFactors must be set as soon as additional BlendModes are added
vk::PipelineColorBlendAttachmentState colorBlendAttachmentState(
- false,
+ config.m_blendMode != BlendMode::None,
vk::BlendFactor::eOne,
vk::BlendFactor::eOne,
vk::BlendOp::eAdd,
@@ -201,14 +224,18 @@ namespace vkcv
{ 1.f,1.f,1.f,1.f }
);
- const size_t matrixPushConstantSize = config.m_ShaderProgram.getPushConstantSize();
- const vk::PushConstantRange pushConstantRange(vk::ShaderStageFlagBits::eAll, 0, matrixPushConstantSize);
+ const size_t pushConstantSize = config.m_ShaderProgram.getPushConstantSize();
+ const vk::PushConstantRange pushConstantRange(vk::ShaderStageFlagBits::eAll, 0, pushConstantSize);
// pipeline layout
vk::PipelineLayoutCreateInfo pipelineLayoutCreateInfo(
{},
(config.m_DescriptorLayouts),
(pushConstantRange));
+ if (pushConstantSize == 0) {
+ pipelineLayoutCreateInfo.pushConstantRangeCount = 0;
+ }
+
vk::PipelineLayout vkPipelineLayout{};
if (m_Device.createPipelineLayout(&pipelineLayoutCreateInfo, nullptr, &vkPipelineLayout) != vk::Result::eSuccess)
@@ -220,9 +247,9 @@ namespace vkcv
const vk::PipelineDepthStencilStateCreateInfo depthStencilCreateInfo(
vk::PipelineDepthStencilStateCreateFlags(),
- true,
- true,
- vk::CompareOp::eLessOrEqual,
+ config.m_depthTest != DepthTest::None,
+ config.m_depthWrite,
+ depthTestToVkCompareOp(config.m_depthTest),
false,
false,
{},
diff --git a/src/vkcv/Swapchain.cpp b/src/vkcv/Swapchain.cpp
index 2c5b3530c396bc3532aa94cb59a120e3555291bf..94e7301d66bfcc513434ef6d22520d1b95f98161 100644
--- a/src/vkcv/Swapchain.cpp
+++ b/src/vkcv/Swapchain.cpp
@@ -78,10 +78,13 @@ namespace vkcv
if(physicalDevice.getSurfaceCapabilitiesKHR(surface,&surfaceCapabilities) != vk::Result::eSuccess){
throw std::runtime_error("cannot get surface capabilities. There is an issue with the surface.");
}
-
+
+ int fb_width, fb_height;
+ window.getFramebufferSize(fb_width, fb_height);
+
VkExtent2D extent2D = {
- static_cast<uint32_t>(window.getWidth()),
- static_cast<uint32_t>(window.getHeight())
+ static_cast<uint32_t>(fb_width),
+ static_cast<uint32_t>(fb_height)
};
extent2D.width = std::max(surfaceCapabilities.minImageExtent.width, std::min(surfaceCapabilities.maxImageExtent.width, extent2D.width));
@@ -218,27 +221,36 @@ namespace vkcv
vk::SwapchainKHR oldSwapchain = m_Swapchain;
vk::Extent2D extent2D = chooseExtent(context.getPhysicalDevice(), m_Surface.handle, window);
- vk::SwapchainCreateInfoKHR swapchainCreateInfo(
- vk::SwapchainCreateFlagsKHR(),
- m_Surface.handle,
- m_ImageCount,
- m_Format,
- m_ColorSpace,
- extent2D,
- 1,
- vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eStorage,
- vk::SharingMode::eExclusive,
- 0,
- nullptr,
- vk::SurfaceTransformFlagBitsKHR::eIdentity,
- vk::CompositeAlphaFlagBitsKHR::eOpaque,
- m_PresentMode,
- true,
- oldSwapchain
- );
-
- m_Swapchain = context.getDevice().createSwapchainKHR(swapchainCreateInfo);
- context.getDevice().destroySwapchainKHR(oldSwapchain);
+ if ((extent2D.width >= MIN_SWAPCHAIN_SIZE) && (extent2D.height >= MIN_SWAPCHAIN_SIZE)) {
+ vk::SwapchainCreateInfoKHR swapchainCreateInfo(
+ vk::SwapchainCreateFlagsKHR(),
+ m_Surface.handle,
+ m_ImageCount,
+ m_Format,
+ m_ColorSpace,
+ extent2D,
+ 1,
+ vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eStorage,
+ vk::SharingMode::eExclusive,
+ 0,
+ nullptr,
+ vk::SurfaceTransformFlagBitsKHR::eIdentity,
+ vk::CompositeAlphaFlagBitsKHR::eOpaque,
+ m_PresentMode,
+ true,
+ oldSwapchain
+ );
+
+ m_Swapchain = context.getDevice().createSwapchainKHR(swapchainCreateInfo);
+ } else {
+ m_Swapchain = nullptr;
+
+ signalSwapchainRecreation();
+ }
+
+ if (oldSwapchain) {
+ context.getDevice().destroySwapchainKHR(oldSwapchain);
+ }
m_Extent = extent2D;
}
diff --git a/src/vkcv/Window.cpp b/src/vkcv/Window.cpp
index 03a58a23b994209c7a0ee195732dc98543f0eddc..ea72582d67d5350e5fbf3f3c0fa2aae2ba407b0e 100644
--- a/src/vkcv/Window.cpp
+++ b/src/vkcv/Window.cpp
@@ -181,4 +181,9 @@ namespace vkcv {
GLFWwindow *Window::getWindow() const {
return m_window;
}
+
+ void Window::getFramebufferSize(int &width, int &height) const {
+ glfwGetFramebufferSize(m_window, &width, &height);
+ }
+
}