diff --git a/.gitmodules b/.gitmodules
index e0aaf2d17c340f98ae875f7e0f1238bfe04f7e5d..317c82a6143d099268c75bfd246ac44e2396cf7c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -22,3 +22,6 @@
[submodule "modules/gui/lib/imgui"]
path = modules/gui/lib/imgui
url = https://github.com/ocornut/imgui.git
+[submodule "lib/VulkanMemoryAllocator-Hpp"]
+ path = lib/VulkanMemoryAllocator-Hpp
+ url = https://github.com/malte-v/VulkanMemoryAllocator-Hpp.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index bff486150f082c2e96e543436d977cf3112403ba..2ae078a428a8e5e640ed8dc7bcc2f4e58e159c6b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -44,6 +44,9 @@ endif()
# configure everything to use the required dependencies
include(${vkcv_config}/Libraries.cmake)
+# set the compile definitions aka preprocessor variables
+add_compile_definitions(${vkcv_definitions})
+
# add modules as targets
add_subdirectory(modules)
@@ -56,9 +59,6 @@ message("-- Flags: [ ${vkcv_flags} ]")
# set the compiler flags for the framework
set(CMAKE_CXX_FLAGS ${vkcv_flags})
-# set the compile definitions aka preprocessor variables
-add_compile_definitions(${vkcv_definitions})
-
# create VkCV framework as static library using all source files
add_library(vkcv STATIC ${vkcv_sources})
diff --git a/config/Libraries.cmake b/config/Libraries.cmake
index e04aa3575a34632eb75c929bf4640305cd93e298..b0684091d59b659c712aeacecd91e200351e0117 100644
--- a/config/Libraries.cmake
+++ b/config/Libraries.cmake
@@ -10,6 +10,8 @@ if(NOT WIN32)
list(APPEND vkcv_flags -fopenmp)
endif()
+list(APPEND vkcv_definitions _USE_MATH_DEFINES)
+
# some formatted printing
set(vkcv_config_msg " - Library: ")
@@ -17,6 +19,7 @@ set(vkcv_config_msg " - Library: ")
include(${vkcv_config_lib}/GLFW.cmake) # glfw-x11 / glfw-wayland # libglfw3-dev
include(${vkcv_config_lib}/Vulkan.cmake) # vulkan-intel / vulkan-radeon / nvidia # libvulkan-dev
include(${vkcv_config_lib}/SPIRV_Cross.cmake) # SPIRV-Cross # libspirv_cross_c_shared
+include(${vkcv_config_lib}/VulkanMemoryAllocator.cmake) # VulkanMemoryAllocator
# cleanup of compiler flags
if (vkcv_flags)
diff --git a/config/Sources.cmake b/config/Sources.cmake
index 4397e4978eb022d267571d185a1f122d053a5ea1..7ae106e2538c66179ab1ed50408551c43b785bc3 100644
--- a/config/Sources.cmake
+++ b/config/Sources.cmake
@@ -21,6 +21,8 @@ set(vkcv_sources
${vkcv_include}/vkcv/Buffer.hpp
+ ${vkcv_include}/vkcv/PushConstants.hpp
+
${vkcv_include}/vkcv/BufferManager.hpp
${vkcv_source}/vkcv/BufferManager.cpp
@@ -80,4 +82,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/config/lib/GLFW.cmake b/config/lib/GLFW.cmake
index 1b68d8aa97ba59158a7bd805ab2470f554f705aa..9668694de5b6887c163f74b626c71873e3f611f8 100644
--- a/config/lib/GLFW.cmake
+++ b/config/lib/GLFW.cmake
@@ -10,6 +10,7 @@ else()
add_subdirectory(${vkcv_lib}/glfw)
list(APPEND vkcv_libraries glfw)
+ list(APPEND vkcv_includes ${vkcv_lib_path}/glfw/include)
message(${vkcv_config_msg} " GLFW - " ${glfw3_VERSION})
else()
diff --git a/config/lib/SPIRV_Cross.cmake b/config/lib/SPIRV_Cross.cmake
index 2e705d7d5a006e3851d14d22a57fd667c61c79f5..00ae45527d0f49c5632d71e19509871d437ae691 100644
--- a/config/lib/SPIRV_Cross.cmake
+++ b/config/lib/SPIRV_Cross.cmake
@@ -25,6 +25,7 @@ else()
add_subdirectory(${vkcv_lib}/SPIRV-Cross)
list(APPEND vkcv_libraries spirv-cross-cpp)
+ list(APPEND vkcv_includes ${vkcv_lib_path}/SPIV-Cross/include)
message(${vkcv_config_msg} " SPIRV Cross - " ${SPIRV_CROSS_VERSION})
else()
diff --git a/config/lib/VulkanMemoryAllocator.cmake b/config/lib/VulkanMemoryAllocator.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5f670ff04633e1747accb8f1598fee028a287168
--- /dev/null
+++ b/config/lib/VulkanMemoryAllocator.cmake
@@ -0,0 +1,22 @@
+
+if (EXISTS "${vkcv_lib_path}/VulkanMemoryAllocator-Hpp")
+ set(VMA_HPP_PATH "${vkcv_lib_path}/VulkanMemoryAllocator-Hpp" CACHE INTERNAL "")
+
+ set(VMA_RECORDING_ENABLED OFF CACHE INTERNAL "")
+ set(VMA_USE_STL_CONTAINERS OFF CACHE INTERNAL "")
+ set(VMA_STATIC_VULKAN_FUNCTIONS ON CACHE INTERNAL "")
+ set(VMA_DYNAMIC_VULKAN_FUNCTIONS OFF CACHE INTERNAL "")
+ set(VMA_DEBUG_ALWAYS_DEDICATED_MEMORY OFF CACHE INTERNAL "")
+ set(VMA_DEBUG_INITIALIZE_ALLOCATIONS OFF CACHE INTERNAL "")
+ set(VMA_DEBUG_GLOBAL_MUTEX OFF CACHE INTERNAL "")
+ set(VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT OFF CACHE INTERNAL "")
+
+ add_subdirectory(${vkcv_config_lib}/vma)
+
+ list(APPEND vkcv_libraries VulkanMemoryAllocator)
+ list(APPEND vkcv_includes ${vkcv_lib_path}/VulkanMemoryAllocator-Hpp)
+
+ message(${vkcv_config_msg} " VMA - ")
+else()
+ message(WARNING "VulkanMemoryAllocator is required..! Update the submodules!")
+endif ()
diff --git a/config/lib/vma/CMakeLists.txt b/config/lib/vma/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a2c018f2b4894e5ce8e2851ca10f981e2af36605
--- /dev/null
+++ b/config/lib/vma/CMakeLists.txt
@@ -0,0 +1,59 @@
+cmake_minimum_required(VERSION 3.9)
+
+project(VulkanMemoryAllocator)
+
+find_package(Vulkan REQUIRED)
+
+option(VMA_HPP_PATH "Location of C++ headers" "")
+
+message(STATUS "VMA_BUILD_SAMPLE = ${VMA_BUILD_SAMPLE}")
+message(STATUS "VMA_BUILD_SAMPLE_SHADERS = ${VMA_BUILD_SAMPLE_SHADERS}")
+message(STATUS "VMA_BUILD_REPLAY = ${VMA_BUILD_REPLAY}")
+
+option(VMA_RECORDING_ENABLED "Enable VMA memory recording for debugging" OFF)
+option(VMA_USE_STL_CONTAINERS "Use C++ STL containers instead of VMA's containers" OFF)
+option(VMA_STATIC_VULKAN_FUNCTIONS "Link statically with Vulkan API" OFF)
+option(VMA_DYNAMIC_VULKAN_FUNCTIONS "Fetch pointers to Vulkan functions internally (no static linking)" ON)
+option(VMA_DEBUG_ALWAYS_DEDICATED_MEMORY "Every allocation will have its own memory block" OFF)
+option(VMA_DEBUG_INITIALIZE_ALLOCATIONS "Automatically fill new allocations and destroyed allocations with some bit pattern" OFF)
+option(VMA_DEBUG_GLOBAL_MUTEX "Enable single mutex protecting all entry calls to the library" OFF)
+option(VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT "Never exceed VkPhysicalDeviceLimits::maxMemoryAllocationCount and return error" OFF)
+
+message(STATUS "VMA_RECORDING_ENABLED = ${VMA_RECORDING_ENABLED}")
+message(STATUS "VMA_USE_STL_CONTAINERS = ${VMA_USE_STL_CONTAINERS}")
+message(STATUS "VMA_DYNAMIC_VULKAN_FUNCTIONS = ${VMA_DYNAMIC_VULKAN_FUNCTIONS}")
+message(STATUS "VMA_DEBUG_ALWAYS_DEDICATED_MEMORY = ${VMA_DEBUG_ALWAYS_DEDICATED_MEMORY}")
+message(STATUS "VMA_DEBUG_INITIALIZE_ALLOCATIONS = ${VMA_DEBUG_INITIALIZE_ALLOCATIONS}")
+message(STATUS "VMA_DEBUG_GLOBAL_MUTEX = ${VMA_DEBUG_GLOBAL_MUTEX}")
+message(STATUS "VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT = ${VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT}")
+
+add_library(VulkanMemoryAllocator vma.cpp)
+
+set_target_properties(
+ VulkanMemoryAllocator PROPERTIES
+
+ CXX_EXTENSIONS OFF
+ # Use C++14
+ CXX_STANDARD 14
+ CXX_STANDARD_REQUIRED ON
+)
+
+target_include_directories(VulkanMemoryAllocator PUBLIC ${VMA_HPP_PATH})
+
+# Only link to Vulkan if static linking is used
+if (NOT ${VMA_DYNAMIC_VULKAN_FUNCTIONS})
+ target_link_libraries(VulkanMemoryAllocator PUBLIC Vulkan::Vulkan)
+endif()
+
+target_compile_definitions(
+ VulkanMemoryAllocator
+
+ PUBLIC
+ VMA_USE_STL_CONTAINERS=$<BOOL:${VMA_USE_STL_CONTAINERS}>
+ VMA_DYNAMIC_VULKAN_FUNCTIONS=$<BOOL:${VMA_DYNAMIC_VULKAN_FUNCTIONS}>
+ VMA_DEBUG_ALWAYS_DEDICATED_MEMORY=$<BOOL:${VMA_DEBUG_ALWAYS_DEDICATED_MEMORY}>
+ VMA_DEBUG_INITIALIZE_ALLOCATIONS=$<BOOL:${VMA_DEBUG_INITIALIZE_ALLOCATIONS}>
+ VMA_DEBUG_GLOBAL_MUTEX=$<BOOL:${VMA_DEBUG_GLOBAL_MUTEX}>
+ VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT=$<BOOL:${VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT}>
+ VMA_RECORDING_ENABLED=$<BOOL:${VMA_RECORDING_ENABLED}>
+)
diff --git a/config/lib/vma/vma.cpp b/config/lib/vma/vma.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0928b552c10e23914054c44b8de43df722aa2cf0
--- /dev/null
+++ b/config/lib/vma/vma.cpp
@@ -0,0 +1,7 @@
+
+#ifndef NDEBUG
+#define _DEBUG
+#endif
+
+#define VMA_IMPLEMENTATION
+#include "vk_mem_alloc.hpp"
diff --git a/include/vkcv/BufferManager.hpp b/include/vkcv/BufferManager.hpp
index 9eb80d70862a79a01593e6fe4c3aabe98d253ac8..c7f32d9f134108bafa87ff493bca4e113d53003a 100644
--- a/include/vkcv/BufferManager.hpp
+++ b/include/vkcv/BufferManager.hpp
@@ -2,6 +2,7 @@
#include <vector>
#include <vulkan/vulkan.hpp>
+#include <vk_mem_alloc.hpp>
#include "Handles.hpp"
@@ -30,9 +31,8 @@ namespace vkcv
struct Buffer
{
vk::Buffer m_handle;
- vk::DeviceMemory m_memory;
+ vma::Allocation m_allocation;
size_t m_size = 0;
- void* m_mapped = nullptr;
bool m_mappable = false;
};
diff --git a/include/vkcv/Context.hpp b/include/vkcv/Context.hpp
index 1c01a6134ba1642b3a130a7a4d3d299cc3f7b875..2ecd9203701510837f49d10c1879efd4890145e9 100644
--- a/include/vkcv/Context.hpp
+++ b/include/vkcv/Context.hpp
@@ -1,6 +1,7 @@
#pragma once
#include <vulkan/vulkan.hpp>
+#include <vk_mem_alloc.hpp>
#include "QueueManager.hpp"
@@ -32,6 +33,9 @@ namespace vkcv
[[nodiscard]]
const QueueManager& getQueueManager() const;
+
+ [[nodiscard]]
+ const vma::Allocator& getAllocator() const;
static Context create(const char *applicationName,
uint32_t applicationVersion,
@@ -47,11 +51,14 @@ namespace vkcv
* @param physicalDevice Vulkan-PhysicalDevice
* @param device Vulkan-Device
*/
- Context(vk::Instance instance, vk::PhysicalDevice physicalDevice, vk::Device device, QueueManager&& queueManager) noexcept;
+ Context(vk::Instance instance, vk::PhysicalDevice physicalDevice, vk::Device device,
+ QueueManager&& queueManager, vma::Allocator&& allocator) noexcept;
vk::Instance m_Instance;
vk::PhysicalDevice m_PhysicalDevice;
vk::Device m_Device;
QueueManager m_QueueManager;
+ vma::Allocator m_Allocator;
+
};
}
diff --git a/include/vkcv/Core.hpp b/include/vkcv/Core.hpp
index c7512346c9137b77c365e807b679b3950925f535..cd3676f45bf0891de97ab88ff74cdd980f6920da 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,19 @@ 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]]
+ uint32_t getImageWidth(ImageHandle imageHandle);
+ [[nodiscard]]
+ uint32_t getImageHeight(ImageHandle imageHandle);
/** TODO:
* @param setDescriptions
@@ -242,7 +246,7 @@ namespace vkcv
const CommandStreamHandle cmdStreamHandle,
const PassHandle renderpassHandle,
const PipelineHandle pipelineHandle,
- const PushConstantData &pushConstantData,
+ const PushConstants &pushConstants,
const std::vector<DrawcallInfo> &drawcalls,
const std::vector<ImageHandle> &renderTargets);
@@ -251,7 +255,7 @@ namespace vkcv
PipelineHandle computePipeline,
const uint32_t dispatchCount[3],
const std::vector<DescriptorSetUsage> &descriptorSetUsages,
- const PushConstantData& pushConstantData);
+ const PushConstants& pushConstants);
/**
* @brief end recording and present image
@@ -285,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/DescriptorConfig.hpp b/include/vkcv/DescriptorConfig.hpp
index c6d0dfd1bc60988afb8b6a9326a8d50d8a4ea32e..776322e6270431f9fa52fd7c3cb4551e5b4bf752 100644
--- a/include/vkcv/DescriptorConfig.hpp
+++ b/include/vkcv/DescriptorConfig.hpp
@@ -11,6 +11,7 @@ namespace vkcv
{
vk::DescriptorSet vulkanHandle;
vk::DescriptorSetLayout layout;
+ size_t poolIndex;
};
/*
diff --git a/include/vkcv/DescriptorWrites.hpp b/include/vkcv/DescriptorWrites.hpp
index 016bdab7c337d3ebada5ed8e9a035606eb937211..f28a6c91e189b13413ffefec0f05e5a0a358ee26 100644
--- a/include/vkcv/DescriptorWrites.hpp
+++ b/include/vkcv/DescriptorWrites.hpp
@@ -4,9 +4,12 @@
namespace vkcv {
struct SampledImageDescriptorWrite {
- inline SampledImageDescriptorWrite(uint32_t binding, ImageHandle image) : binding(binding), image(image) {};
+ inline SampledImageDescriptorWrite(uint32_t binding, ImageHandle image, uint32_t mipLevel = 0, bool useGeneralLayout = false)
+ : binding(binding), image(image), mipLevel(mipLevel), useGeneralLayout(useGeneralLayout) {};
uint32_t binding;
ImageHandle image;
+ uint32_t mipLevel;
+ bool useGeneralLayout;
};
struct StorageImageDescriptorWrite {
@@ -38,8 +41,8 @@ namespace vkcv {
struct DescriptorWrites {
std::vector<SampledImageDescriptorWrite> sampledImageWrites;
std::vector<StorageImageDescriptorWrite> storageImageWrites;
- std::vector<UniformBufferDescriptorWrite> uniformBufferWrites;
- std::vector<StorageBufferDescriptorWrite> storageBufferWrites;
- std::vector<SamplerDescriptorWrite> samplerWrites;
+ std::vector<UniformBufferDescriptorWrite> uniformBufferWrites;
+ std::vector<StorageBufferDescriptorWrite> storageBufferWrites;
+ std::vector<SamplerDescriptorWrite> samplerWrites;
};
}
\ No newline at end of file
diff --git a/include/vkcv/DrawcallRecording.hpp b/include/vkcv/DrawcallRecording.hpp
index 0929ad038fb95ec1573e7c76e5ce13adb84ab760..572fc2b6b51735bdcd7eb77c1dd9d4a3482a1640 100644
--- a/include/vkcv/DrawcallRecording.hpp
+++ b/include/vkcv/DrawcallRecording.hpp
@@ -2,6 +2,7 @@
#include <vulkan/vulkan.hpp>
#include <vkcv/Handles.hpp>
#include <vkcv/DescriptorConfig.hpp>
+#include <vkcv/PushConstants.hpp>
namespace vkcv {
struct VertexBufferBinding {
@@ -29,26 +30,20 @@ namespace vkcv {
size_t indexCount;
};
- struct PushConstantData {
- inline PushConstantData(void* data, size_t sizePerDrawcall) : data(data), sizePerDrawcall(sizePerDrawcall) {}
-
- void* data;
- size_t sizePerDrawcall;
- };
-
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(
const DrawcallInfo &drawcall,
vk::CommandBuffer cmdBuffer,
vk::PipelineLayout pipelineLayout,
- const PushConstantData &pushConstantData,
+ const PushConstants &pushConstants,
const size_t drawcallIndex);
}
\ No newline at end of file
diff --git a/include/vkcv/Event.hpp b/include/vkcv/Event.hpp
index e324917674cd2e1773ee23a9411ab28f6eb0d684..da5cbc72fbb3eee3a71a35c1da6fe32dff06b057 100644
--- a/include/vkcv/Event.hpp
+++ b/include/vkcv/Event.hpp
@@ -1,6 +1,7 @@
#pragma once
#include <functional>
+#include <mutex>
namespace vkcv {
@@ -26,6 +27,7 @@ namespace vkcv {
private:
std::vector< event_function<T...> > m_functions;
uint32_t m_id_counter;
+ std::mutex m_mutex;
public:
@@ -34,9 +36,13 @@ namespace vkcv {
* @param arguments of the given function
*/
void operator()(T... arguments) {
+ lock();
+
for (auto &function : this->m_functions) {
function.callback(arguments...);
- }
+ }
+
+ unlock();
}
/**
@@ -64,8 +70,26 @@ namespace vkcv {
this->m_functions.end()
);
}
+
+ /**
+ * locks the event so its function handles won't be called
+ */
+ void lock() {
+ m_mutex.lock();
+ }
+
+ /**
+ * unlocks the event so its function handles can be called after locking
+ */
+ void unlock() {
+ m_mutex.unlock();
+ }
- event() = default;
+ explicit event(bool locked = false) {
+ if (locked) {
+ lock();
+ }
+ }
event(const event &other) = delete;
diff --git a/include/vkcv/Image.hpp b/include/vkcv/Image.hpp
index 9e1f9708c6318aa6deb750097c414358ffde2c65..3fca76f70315c0e08e404d7acd8c2010a3501c24 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);
@@ -31,32 +31,35 @@ namespace vkcv {
uint32_t getDepth() const;
[[nodiscard]]
- vkcv::ImageHandle getHandle() const;
+ const vkcv::ImageHandle& getHandle() const;
[[nodiscard]]
uint32_t getMipCount() const;
void switchLayout(vk::ImageLayout newLayout);
- void fill(void* data, size_t size = SIZE_MAX);
+ void fill(const void* data, size_t size = SIZE_MAX);
void generateMipChainImmediate();
void recordMipChainGeneration(const vkcv::CommandStreamHandle& cmdStream);
private:
- ImageManager* const m_manager;
- const ImageHandle m_handle;
+ // TODO: const qualifier removed, very hacky!!!
+ // Else you cannot recreate an image. Pls fix.
+ ImageManager* m_manager;
+ ImageHandle m_handle;
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/Logger.hpp b/include/vkcv/Logger.hpp
index 251b6b528c45ea509dbfcd0cfb7135b77031f1ac..1ae0f211e1a3255d624cf78985b0797e9d90c634 100644
--- a/include/vkcv/Logger.hpp
+++ b/include/vkcv/Logger.hpp
@@ -1,10 +1,11 @@
#pragma once
-#include <iostream>
+#include <stdio.h>
namespace vkcv {
enum class LogLevel {
+ RAW_INFO,
INFO,
WARNING,
ERROR
@@ -12,6 +13,7 @@ namespace vkcv {
constexpr auto getLogOutput(LogLevel level) {
switch (level) {
+ case LogLevel::RAW_INFO:
case LogLevel::INFO:
return stdout;
default:
@@ -21,6 +23,7 @@ namespace vkcv {
constexpr const char* getLogName(LogLevel level) {
switch (level) {
+ case LogLevel::RAW_INFO:
case LogLevel::INFO:
return "INFO";
case LogLevel::WARNING:
@@ -41,24 +44,33 @@ namespace vkcv {
#define __PRETTY_FUNCTION__ __FUNCSIG__
#endif
-#define vkcv_log(level, ...) { \
- char output_message [ \
- VKCV_DEBUG_MESSAGE_LEN \
- ]; \
- std::snprintf( \
- output_message, \
- VKCV_DEBUG_MESSAGE_LEN, \
- __VA_ARGS__ \
- ); \
- std::fprintf( \
- getLogOutput(level), \
- "[%s]: %s [%s, line %d: %s]\n", \
- vkcv::getLogName(level), \
- output_message, \
- __FILE__, \
- __LINE__, \
- __PRETTY_FUNCTION__ \
- ); \
+#define vkcv_log(level, ...) { \
+ char output_message [ \
+ VKCV_DEBUG_MESSAGE_LEN \
+ ]; \
+ snprintf( \
+ output_message, \
+ VKCV_DEBUG_MESSAGE_LEN, \
+ __VA_ARGS__ \
+ ); \
+ if (level != vkcv::LogLevel::RAW_INFO) { \
+ fprintf( \
+ getLogOutput(level), \
+ "[%s]: %s [%s, line %d: %s]\n", \
+ vkcv::getLogName(level), \
+ output_message, \
+ __FILE__, \
+ __LINE__, \
+ __PRETTY_FUNCTION__ \
+ ); \
+ } else { \
+ fprintf( \
+ getLogOutput(level), \
+ "[%s]: %s\n", \
+ vkcv::getLogName(level), \
+ output_message \
+ ); \
+ } \
}
#else
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/PushConstants.hpp b/include/vkcv/PushConstants.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..d974fbe6241daf948b13929305fb24aff5ec06f5
--- /dev/null
+++ b/include/vkcv/PushConstants.hpp
@@ -0,0 +1,93 @@
+#pragma once
+
+#include <vector>
+#include <vulkan/vulkan.hpp>
+
+#include "Logger.hpp"
+
+namespace vkcv {
+
+ class PushConstants {
+ private:
+ std::vector<uint8_t> m_data;
+ size_t m_sizePerDrawcall;
+
+ public:
+ template<typename T>
+ PushConstants() : PushConstants(sizeof(T)) {}
+
+ explicit PushConstants(size_t sizePerDrawcall) :
+ m_data(),
+ m_sizePerDrawcall(sizePerDrawcall) {}
+
+ PushConstants(const PushConstants& other) = default;
+ PushConstants(PushConstants&& other) = default;
+
+ ~PushConstants() = default;
+
+ PushConstants& operator=(const PushConstants& other) = default;
+ PushConstants& operator=(PushConstants&& other) = default;
+
+ [[nodiscard]]
+ size_t getSizePerDrawcall() const {
+ return m_sizePerDrawcall;
+ }
+
+ [[nodiscard]]
+ size_t getFullSize() const {
+ return m_data.size();
+ }
+
+ [[nodiscard]]
+ size_t getDrawcallCount() const {
+ return (m_data.size() / m_sizePerDrawcall);
+ }
+
+ void clear() {
+ m_data.clear();
+ }
+
+ template<typename T = uint8_t>
+ bool appendDrawcall(const T& value) {
+ if (sizeof(T) != m_sizePerDrawcall) {
+ vkcv_log(LogLevel::WARNING, "Size (%lu) of value does not match the specified size per drawcall (%lu)",
+ sizeof(value), m_sizePerDrawcall);
+ return false;
+ }
+
+ const size_t offset = m_data.size();
+ m_data.resize(offset + sizeof(value));
+ std::memcpy(m_data.data() + offset, &value, sizeof(value));
+ return true;
+ }
+
+ template<typename T = uint8_t>
+ T& getDrawcall(size_t index) {
+ const size_t offset = (index * m_sizePerDrawcall);
+ return *reinterpret_cast<T*>(m_data.data() + offset);
+ }
+
+ template<typename T = uint8_t>
+ const T& getDrawcall(size_t index) const {
+ const size_t offset = (index * m_sizePerDrawcall);
+ return *reinterpret_cast<const T*>(m_data.data() + offset);
+ }
+
+ [[nodiscard]]
+ const void* getDrawcallData(size_t index) const {
+ const size_t offset = (index * m_sizePerDrawcall);
+ return reinterpret_cast<const void*>(m_data.data() + offset);
+ }
+
+ [[nodiscard]]
+ const void* getData() const {
+ if (m_data.empty()) {
+ return nullptr;
+ } else {
+ return m_data.data();
+ }
+ }
+
+ };
+
+}
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 51d6e2245a8b588334b38254c05276ee0eb10150..f3b3a8fe88ae6e8791d7d92361ad5b6bf2447dcb 100644
--- a/include/vkcv/Window.hpp
+++ b/include/vkcv/Window.hpp
@@ -7,6 +7,7 @@
#define NOMINMAX
#include <algorithm>
+
#include "Event.hpp"
struct GLFWwindow;
@@ -23,8 +24,6 @@ namespace vkcv {
*/
explicit Window(GLFWwindow *window);
- static GLFWwindow* createGLFWWindow(const char *windowTitle, int width, int height, bool resizable);
-
private:
/**
* mouse callback for moving the mouse on the screen
@@ -42,6 +41,12 @@ namespace vkcv {
*/
static void onMouseButtonEvent(GLFWwindow *callbackWindow, int button, int action, int mods);
+ /**
+ * @brief A callback function for handling mouse scrolling events.
+ * @param[in] callbackWindow The window that received the event.
+ * @param[in] xoffset The extent of horizontal scrolling.
+ * @param[in] yoffset The extent of vertical scrolling.
+ */
static void onMouseScrollEvent(GLFWwindow *callbackWindow, double xoffset, double yoffset);
/**
@@ -69,6 +74,12 @@ namespace vkcv {
*/
static void onCharEvent(GLFWwindow *callbackWindow, unsigned int c);
+ /**
+ * @brief A callback function for gamepad input events.
+ * @param gamepadIndex The gamepad index.
+ */
+ static void onGamepadEvent(int gamepadIndex);
+
public:
/**
* creates a GLFWwindow with the parameters in the function
@@ -87,11 +98,6 @@ namespace vkcv {
[[nodiscard]]
bool isWindowOpen() const;
- /**
- * binds windowEvents to lambda events
- */
- void initEvents();
-
/**
* polls all events on the GLFWwindow
*/
@@ -106,6 +112,7 @@ namespace vkcv {
event< int, int > e_resize;
event< int, int, int, int > e_key;
event< unsigned int > e_char;
+ event< int > e_gamepad;
/**
* returns the current window
@@ -150,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;
};
-}
\ No newline at end of file
+}
diff --git a/lib/VulkanMemoryAllocator-Hpp b/lib/VulkanMemoryAllocator-Hpp
new file mode 160000
index 0000000000000000000000000000000000000000..eae6e8d3bd4593e0d7071c85fba2a8f33fbe5dab
--- /dev/null
+++ b/lib/VulkanMemoryAllocator-Hpp
@@ -0,0 +1 @@
+Subproject commit eae6e8d3bd4593e0d7071c85fba2a8f33fbe5dab
diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
index 5edb802b3adf16878c2dec4050d8444278739026..802200ad5deb76decbb75e30e1fbd14bff3b7e3b 100644
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@@ -3,5 +3,7 @@
add_subdirectory(asset_loader)
add_subdirectory(camera)
add_subdirectory(gui)
+add_subdirectory(material)
+add_subdirectory(scene)
add_subdirectory(shader_compiler)
add_subdirectory(testing)
diff --git a/modules/asset_loader/CMakeLists.txt b/modules/asset_loader/CMakeLists.txt
index a0f6e76f08804438193891aefb596e87a34ed530..870c16279b1578224a966a4a123a465413333555 100644
--- a/modules/asset_loader/CMakeLists.txt
+++ b/modules/asset_loader/CMakeLists.txt
@@ -38,3 +38,5 @@ target_include_directories(vkcv_asset_loader SYSTEM BEFORE PRIVATE ${vkcv_asset_
# add the own include directory for public headers
target_include_directories(vkcv_asset_loader BEFORE PUBLIC ${vkcv_asset_loader_include})
+
+target_compile_definitions(vkcv_asset_loader PUBLIC ${vkcv_asset_loader_definitions})
diff --git a/modules/asset_loader/config/STB.cmake b/modules/asset_loader/config/STB.cmake
index da20d3ec07f98c865b4c6e38518f668b226cbfb9..1287d0a9ddda559e061ddd680bc815e24b3e2075 100644
--- a/modules/asset_loader/config/STB.cmake
+++ b/modules/asset_loader/config/STB.cmake
@@ -1,6 +1,10 @@
if (EXISTS "${vkcv_asset_loader_lib_path}/stb")
list(APPEND vkcv_asset_loader_includes ${vkcv_asset_loader_lib}/stb)
+
+ list(APPEND vkcv_asset_loader_definitions STB_IMAGE_IMPLEMENTATION)
+ list(APPEND vkcv_asset_loader_definitions STBI_ONLY_JPEG)
+ list(APPEND vkcv_asset_loader_definitions STBI_ONLY_PNG)
else()
message(WARNING "STB is required..! Update the submodules!")
endif ()
diff --git a/modules/asset_loader/include/vkcv/asset/asset_loader.hpp b/modules/asset_loader/include/vkcv/asset/asset_loader.hpp
index 2968cd7c3745ce926059e2ccdbd457758a1a2aa1..98ee7646bae69a7724b30762c6604a5c6a5a0b57 100644
--- a/modules/asset_loader/include/vkcv/asset/asset_loader.hpp
+++ b/modules/asset_loader/include/vkcv/asset/asset_loader.hpp
@@ -136,7 +136,7 @@ bool materialHasTexture(const Material *const m, const PBRTextureTarget t);
/* With these enums, 0 is reserved to signal uninitialized or invalid data. */
enum class PrimitiveType : uint32_t {
UNDEFINED = 0, POSITION = 1, NORMAL, TANGENT, TEXCOORD_0, TEXCOORD_1,
- COLOR_0, JOINTS_0, WEIGHTS_0
+ COLOR_0, COLOR_1, JOINTS_0, WEIGHTS_0
};
/**
@@ -219,5 +219,12 @@ typedef struct {
*/
int loadScene(const std::filesystem::path &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 eaaf1164475e2a17cb3039c3132796cf67af095a..9e59e9fa05a515f39d0f61e97700b5054124d737 100644
--- a/modules/asset_loader/src/vkcv/asset/asset_loader.cpp
+++ b/modules/asset_loader/src/vkcv/asset/asset_loader.cpp
@@ -2,11 +2,8 @@
#include <iostream>
#include <string.h> // memcpy(3)
#include <stdlib.h> // calloc(3)
-#include <fx/gltf.h>
#include <vulkan/vulkan.hpp>
-#define STB_IMAGE_IMPLEMENTATION
-#define STBI_ONLY_JPEG
-#define STBI_ONLY_PNG
+#include <fx/gltf.h>
#include <stb_image.h>
#include <vkcv/Logger.hpp>
#include <algorithm>
@@ -73,6 +70,7 @@ enum IndexType getIndexType(const enum fx::gltf::Accessor::ComponentType &type)
case fx::gltf::Accessor::ComponentType::UnsignedInt:
return IndexType::UINT32;
default:
+ vkcv_log(LogLevel::ERROR, "Index type not supported: %u", static_cast<uint16_t>(type));
return IndexType::UNDEFINED;
}
}
@@ -172,8 +170,10 @@ int createVertexAttributes(const fx::gltf::Attributes &src,
att.type = PrimitiveType::TEXCOORD_0;
} else if (attrib.first == "TEXCOORD_1") {
att.type = PrimitiveType::TEXCOORD_1;
- } else if (attrib.first == "COLOR0") {
+ } else if (attrib.first == "COLOR_0") {
att.type = PrimitiveType::COLOR_0;
+ } else if (attrib.first == "COLOR_1") {
+ att.type = PrimitiveType::COLOR_1;
} else if (attrib.first == "JOINTS_0") {
att.type = PrimitiveType::JOINTS_0;
} else if (attrib.first == "WEIGHTS_0") {
@@ -567,7 +567,6 @@ int loadScene(const std::filesystem::path &path, Scene &scene){
vkcv_log(LogLevel::ERROR, "Failed to get Vertex Groups!");
return ASSET_ERROR;
}
-
Mesh mesh = {};
mesh.name = sceneObjects.meshes[i].name;
@@ -617,4 +616,23 @@ int loadScene(const std::filesystem::path &path, Scene &scene){
return ASSET_SUCCESS;
}
+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/CMakeLists.txt b/modules/camera/CMakeLists.txt
index 73f2dd1c81be9c6cadf563f7936bfaba8c1d0025..60cfca4cf97cef30d989bdab064e20547764041c 100644
--- a/modules/camera/CMakeLists.txt
+++ b/modules/camera/CMakeLists.txt
@@ -36,3 +36,4 @@ target_include_directories(vkcv_camera SYSTEM BEFORE PRIVATE ${vkcv_camera_inclu
# add the own include directory for public headers
target_include_directories(vkcv_camera BEFORE PUBLIC ${vkcv_camera_include} ${vkcv_camera_includes})
+target_compile_definitions(vkcv_camera PUBLIC ${vkcv_camera_definitions})
diff --git a/modules/camera/config/GLM.cmake b/modules/camera/config/GLM.cmake
index c4d14392ef0ea24243a45b19cd8583d90d3267be..efd6444451100b912aa0b5b4a532dc8f448b0b40 100644
--- a/modules/camera/config/GLM.cmake
+++ b/modules/camera/config/GLM.cmake
@@ -4,11 +4,17 @@ find_package(glm QUIET)
if (glm_FOUND)
list(APPEND vkcv_camera_includes ${GLM_INCLUDE_DIRS})
list(APPEND vkcv_camera_libraries glm)
+
+ list(APPEND vkcv_camera_definitions GLM_DEPTH_ZERO_TO_ONE)
+ list(APPEND vkcv_camera_definitions GLM_FORCE_LEFT_HANDED)
else()
if (EXISTS "${vkcv_camera_lib_path}/glm")
add_subdirectory(${vkcv_camera_lib}/glm)
list(APPEND vkcv_camera_libraries glm)
+
+ list(APPEND vkcv_camera_definitions GLM_DEPTH_ZERO_TO_ONE)
+ list(APPEND vkcv_camera_definitions GLM_FORCE_LEFT_HANDED)
else()
message(WARNING "GLM is required..! Update the submodules!")
endif ()
diff --git a/modules/camera/include/vkcv/camera/Camera.hpp b/modules/camera/include/vkcv/camera/Camera.hpp
index dc9f2dcb3038655f51fb2404abc21f98a2120399..8a8c5df5d74cf1402bd8810172657ba77ddb2d56 100644
--- a/modules/camera/include/vkcv/camera/Camera.hpp
+++ b/modules/camera/include/vkcv/camera/Camera.hpp
@@ -1,10 +1,10 @@
#pragma once
-#define GLM_DEPTH_ZERO_TO_ONE
-#define GLM_FORCE_LEFT_HANDED
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/matrix_access.hpp>
+#include <glm/vec3.hpp>
+#include <glm/mat4x4.hpp>
namespace vkcv::camera {
@@ -22,9 +22,6 @@ namespace vkcv::camera {
glm::vec3 m_up;
glm::vec3 m_position;
glm::vec3 m_center;
-
- float m_pitch;
- float m_yaw;
/**
* @brief Sets the view matrix of the camera to @p view
@@ -158,6 +155,20 @@ namespace vkcv::camera {
* @param[in] center The new center point.
*/
void setCenter(const glm::vec3& center);
+
+ /**
+ * @brief Gets the angles of the camera.
+ * @param[out] pitch The pitch value in radians
+ * @param[out] yaw The yaw value in radians
+ */
+ void getAngles(float& pitch, float& yaw);
+
+ /**
+ * @brief Sets the angles of the camera.
+ * @param pitch The new pitch value in radians
+ * @param yaw The new yaw value in radians
+ */
+ void setAngles(float pitch, float yaw);
/**
* @brief Gets the pitch value of the camera in degrees.
diff --git a/modules/camera/include/vkcv/camera/CameraController.hpp b/modules/camera/include/vkcv/camera/CameraController.hpp
index 5fe7aba586068beff15525617d8e4817662746b7..90fc97401851851194ec89a10757bbfb1453990d 100644
--- a/modules/camera/include/vkcv/camera/CameraController.hpp
+++ b/modules/camera/include/vkcv/camera/CameraController.hpp
@@ -59,6 +59,14 @@ namespace vkcv::camera {
* @param[in] camera The camera object.
*/
virtual void mouseButtonCallback(int button, int action, int mods, Camera &camera) = 0;
+
+ /**
+ * @brief A callback function for gamepad input events.
+ * @param gamepadIndex The gamepad index.
+ * @param camera The camera object.
+ * @param frametime The current frametime.
+ */
+ virtual void gamepadCallback(int gamepadIndex, Camera &camera, double frametime) = 0;
};
}
\ No newline at end of file
diff --git a/modules/camera/include/vkcv/camera/CameraManager.hpp b/modules/camera/include/vkcv/camera/CameraManager.hpp
index 5755d6cdc20f0321197b7755e459725eb363fc90..409f9196599be02e4215f3924c1102f0b8c72899 100644
--- a/modules/camera/include/vkcv/camera/CameraManager.hpp
+++ b/modules/camera/include/vkcv/camera/CameraManager.hpp
@@ -30,6 +30,7 @@ namespace vkcv::camera {
event_handle<double, double> m_mouseScrollHandle;
event_handle<int, int, int> m_mouseButtonHandle;
event_handle<int, int> m_resizeHandle;
+ event_handle<int> m_gamepadHandle;
Window& m_window;
std::vector<Camera> m_cameras;
@@ -42,6 +43,9 @@ namespace vkcv::camera {
double m_lastX;
double m_lastY;
+ double m_inputDelayTimer;
+ double m_frameTime;
+
/**
* @brief Binds the camera object to the window event handles.
*/
@@ -86,6 +90,13 @@ namespace vkcv::camera {
* @param[in] height The new height of the window.
*/
void resizeCallback(int width, int height);
+
+ /**
+ * @brief A callback function for gamepad input events. Currently, inputs are handled only for the first
+ * connected gamepad!
+ * @param gamepadIndex The gamepad index.
+ */
+ void gamepadCallback(int gamepadIndex);
/**
* @brief Gets a camera controller object of specified @p controllerType.
diff --git a/modules/camera/include/vkcv/camera/PilotCameraController.hpp b/modules/camera/include/vkcv/camera/PilotCameraController.hpp
index c6a9f7c7ffa9a3be77f12c29e456291fb8f6b845..2b64cdc0dd3045714aba7b3b7c6241af2337c706 100644
--- a/modules/camera/include/vkcv/camera/PilotCameraController.hpp
+++ b/modules/camera/include/vkcv/camera/PilotCameraController.hpp
@@ -17,6 +17,10 @@ namespace vkcv::camera {
bool m_left;
bool m_right;
+ float m_gamepadX;
+ float m_gamepadY;
+ float m_gamepadZ;
+
bool m_rotationActive;
float m_cameraSpeed;
@@ -133,6 +137,14 @@ namespace vkcv::camera {
* @param[in] camera The camera object.
*/
void mouseButtonCallback(int button, int action, int mods, Camera &camera);
+
+ /**
+ * @brief A callback function for gamepad input events.
+ * @param gamepadIndex The gamepad index.
+ * @param camera The camera object.
+ * @param frametime The current frametime.
+ */
+ void gamepadCallback(int gamepadIndex, Camera &camera, double frametime);
};
}
\ No newline at end of file
diff --git a/modules/camera/include/vkcv/camera/TrackballCameraController.hpp b/modules/camera/include/vkcv/camera/TrackballCameraController.hpp
index 0211043a9c6b862df8e500af190ad1f75a3c78aa..20336f7a10644c73e451c5106f37545e84eb27f7 100644
--- a/modules/camera/include/vkcv/camera/TrackballCameraController.hpp
+++ b/modules/camera/include/vkcv/camera/TrackballCameraController.hpp
@@ -14,6 +14,8 @@ namespace vkcv::camera {
float m_cameraSpeed;
float m_scrollSensitivity;
float m_radius;
+ float m_pitch;
+ float m_yaw;
/**
* @brief Updates the current radius of @p camera in respect to the @p offset.
@@ -95,6 +97,13 @@ namespace vkcv::camera {
*/
void mouseButtonCallback(int button, int action, int mods, Camera &camera);
+ /**
+ * @brief A callback function for gamepad input events.
+ * @param gamepadIndex The gamepad index.
+ * @param camera The camera object.
+ * @param frametime The current frametime.
+ */
+ void gamepadCallback(int gamepadIndex, Camera &camera, double frametime);
};
}
\ No newline at end of file
diff --git a/modules/camera/src/vkcv/camera/Camera.cpp b/modules/camera/src/vkcv/camera/Camera.cpp
index eb1857968b2284287691c6ed41ba168db30d3f84..87d09aa9a6e3e7dc80d5de9a95f3e1e3b72e9205 100644
--- a/modules/camera/src/vkcv/camera/Camera.cpp
+++ b/modules/camera/src/vkcv/camera/Camera.cpp
@@ -1,6 +1,5 @@
#include "vkcv/camera/Camera.hpp"
-#define _USE_MATH_DEFINES
#include <math.h>
namespace vkcv::camera {
@@ -11,8 +10,6 @@ namespace vkcv::camera {
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f)
);
-
- setFront(glm::normalize(m_center - m_position));
}
Camera::~Camera() = default;
@@ -38,27 +35,27 @@ namespace vkcv::camera {
m_view = view;
}
+ 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
+ );
+
const glm::mat4& Camera::getProjection() const {
return m_projection;
}
void Camera::setProjection(const glm::mat4& projection) {
- m_projection = projection;
+ m_projection = 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;
+ return m_projection * m_view;
}
float Camera::getFov() const {
- const float tanHalfFovy = 1.0f / m_projection[1][1];
+ const float tanHalfFovy = -1.0f / m_projection[1][1];
float halfFovy = std::atan(tanHalfFovy);
if (halfFovy < 0) {
@@ -74,7 +71,7 @@ namespace vkcv::camera {
float Camera::getRatio() const {
const float aspectProduct = 1.0f / m_projection[0][0];
- const float tanHalfFovy = 1.0f / m_projection[1][1];
+ const float tanHalfFovy = -1.0f / m_projection[1][1];
return aspectProduct / tanHalfFovy;
}
@@ -94,16 +91,11 @@ namespace vkcv::camera {
}
glm::vec3 Camera::getFront() const {
- glm::vec3 direction;
- direction.x = std::sin(glm::radians(m_yaw)) * std::cos(glm::radians(m_pitch));
- direction.y = std::sin(glm::radians(m_pitch));
- direction.z = std::cos(glm::radians(m_yaw)) * std::cos(glm::radians(m_pitch));
- return glm::normalize(direction);
+ return glm::normalize(m_center - m_position);
}
void Camera::setFront(const glm::vec3 &front) {
- m_pitch = std::atan2(front.y, std::sqrt(front.x * front.x + front.z * front.z));
- m_yaw = std::atan2(front.x, front.z);
+ setCenter(m_position + front);
}
const glm::vec3& Camera::getPosition() const {
@@ -129,21 +121,47 @@ namespace vkcv::camera {
void Camera::setUp(const glm::vec3 &up) {
lookAt(m_position, m_center, up);
}
-
- float Camera::getPitch() const {
- return m_pitch;
+
+ void Camera::getAngles(float& pitch, float& yaw) {
+ const auto front = getFront();
+
+ pitch = std::atan2(front[1], std::sqrt(
+ front[0] * front[0] + front[2] * front[2]
+ ));
+
+ yaw = std::atan2(front[0], front[2]);
+ }
+
+ void Camera::setAngles(float pitch, float yaw) {
+ float cosPitch = std::cos(pitch);
+
+ setFront(glm::vec3(
+ std::sin(yaw) * cosPitch,
+ std::sin(pitch),
+ std::cos(yaw) * cosPitch
+ ));
+ }
+
+ float Camera::getPitch() const {
+ const auto front = getFront();
+
+ return glm::degrees(std::atan2(front[1], std::sqrt(
+ front[0] * front[0] + front[2] * front[2]
+ )));
}
void Camera::setPitch(float pitch) {
- m_pitch = pitch;
+ setAngles(glm::radians(pitch), glm::radians(getYaw()));
}
float Camera::getYaw() const {
- return m_yaw;
+ const auto front = getFront();
+
+ return glm::degrees(std::atan2(front[0], front[2]));
}
void Camera::setYaw(float yaw) {
- m_yaw = yaw;
+ setAngles(glm::radians(getPitch()), glm::radians(yaw));
}
}
\ No newline at end of file
diff --git a/modules/camera/src/vkcv/camera/CameraManager.cpp b/modules/camera/src/vkcv/camera/CameraManager.cpp
index 84a0d7ca3049846c4fbb234bab02b5f4d3c7ffd5..f129f3a248325957cb56470e2547a0146bc7c971 100644
--- a/modules/camera/src/vkcv/camera/CameraManager.cpp
+++ b/modules/camera/src/vkcv/camera/CameraManager.cpp
@@ -1,6 +1,5 @@
#include "vkcv/camera/CameraManager.hpp"
-
#include <vkcv/Logger.hpp>
namespace vkcv::camera {
@@ -12,6 +11,8 @@ namespace vkcv::camera {
m_activeCameraIndex = 0;
m_lastX = static_cast<float>(window.getWidth()) / 2.0f;
m_lastY = static_cast<float>(window.getHeight()) / 2.0f;
+ m_inputDelayTimer = glfwGetTime() + 0.2;
+ m_frameTime = 0;
}
CameraManager::~CameraManager() {
@@ -20,6 +21,7 @@ namespace vkcv::camera {
m_window.e_mouseScroll.remove(m_mouseScrollHandle);
m_window.e_mouseButton.remove(m_mouseButtonHandle);
m_window.e_resize.remove(m_resizeHandle);
+ m_window.e_gamepad.remove(m_gamepadHandle);
}
void CameraManager::bindCameraToEvents() {
@@ -28,11 +30,14 @@ namespace vkcv::camera {
m_mouseScrollHandle = m_window.e_mouseScroll.add([&](double offsetX, double offsetY) {this->scrollCallback( offsetX, offsetY);} );
m_mouseButtonHandle = m_window.e_mouseButton.add([&] (int button, int action, int mods) {this->mouseButtonCallback( button, action, mods);});
m_resizeHandle = m_window.e_resize.add([&](int width, int height) {this->resizeCallback(width, height);});
+ m_gamepadHandle = m_window.e_gamepad.add([&](int gamepadIndex) {this->gamepadCallback(gamepadIndex);});
}
void CameraManager::resizeCallback(int width, int height) {
- for (size_t i = 0; i < m_cameras.size(); i++) {
- getCamera(i).setRatio(static_cast<float>(width) / static_cast<float>(height));;
+ if (glfwGetWindowAttrib(m_window.getWindow(), GLFW_ICONIFIED) == GLFW_FALSE) {
+ for (size_t i = 0; i < m_cameras.size(); i++) {
+ getCamera(i).setRatio(static_cast<float>(width) / static_cast<float>(height));;
+ }
}
}
@@ -81,7 +86,29 @@ namespace vkcv::camera {
break;
}
}
-
+
+ void CameraManager::gamepadCallback(int gamepadIndex) {
+ // handle camera switching
+ GLFWgamepadstate gamepadState;
+ glfwGetGamepadState(gamepadIndex, &gamepadState);
+
+ double time = glfwGetTime();
+ if (time - m_inputDelayTimer > 0.2) {
+ int switchDirection = gamepadState.buttons[GLFW_GAMEPAD_BUTTON_DPAD_RIGHT] - gamepadState.buttons[GLFW_GAMEPAD_BUTTON_DPAD_LEFT];
+ m_activeCameraIndex += switchDirection;
+ if (std::greater<int>{}(m_activeCameraIndex, m_cameras.size() - 1)) {
+ m_activeCameraIndex = 0;
+ }
+ else if (std::less<int>{}(m_activeCameraIndex, 0)) {
+ m_activeCameraIndex = m_cameras.size() - 1;
+ }
+ uint32_t triggered = abs(switchDirection);
+ m_inputDelayTimer = (1-triggered)*m_inputDelayTimer + triggered * time; // Only reset timer, if dpad was pressed - is this cheaper than if-clause?
+ }
+
+ getActiveController().gamepadCallback(gamepadIndex, getActiveCamera(), m_frameTime); // handle camera rotation, translation
+ }
+
CameraController& CameraManager::getActiveController() {
const ControllerType type = getControllerType(getActiveCameraIndex());
return getControllerByType(type);
@@ -158,7 +185,10 @@ namespace vkcv::camera {
}
void CameraManager::update(double deltaTime) {
- getActiveController().updateCamera(deltaTime, getActiveCamera());
+ m_frameTime = deltaTime;
+ if (glfwGetWindowAttrib(m_window.getWindow(), GLFW_FOCUSED) == GLFW_TRUE) {
+ getActiveController().updateCamera(deltaTime, getActiveCamera());
+ }
}
-}
\ No newline at end of file
+}
diff --git a/modules/camera/src/vkcv/camera/PilotCameraController.cpp b/modules/camera/src/vkcv/camera/PilotCameraController.cpp
index 1a50a0efa4b4e75adb81ce869d6b927bd0046758..28ef7c6943428078589047497fc2d3b44fde5fd7 100644
--- a/modules/camera/src/vkcv/camera/PilotCameraController.cpp
+++ b/modules/camera/src/vkcv/camera/PilotCameraController.cpp
@@ -1,5 +1,4 @@
#include "vkcv/camera/PilotCameraController.hpp"
-
#include <GLFW/glfw3.h>
namespace vkcv::camera {
@@ -12,9 +11,13 @@ namespace vkcv::camera {
m_left = false;
m_right = false;
+ m_gamepadX = 0.0f;
+ m_gamepadY = 0.0f;
+ m_gamepadZ = 0.0f;
+
m_rotationActive = false;
- m_cameraSpeed = 2.0f;
+ m_cameraSpeed = 2.5f;
m_fov_nsteps = 100;
m_fov_min = 10;
@@ -22,6 +25,11 @@ namespace vkcv::camera {
}
void PilotCameraController::changeFov(double offset, Camera &camera){
+ // update only if there is (valid) input
+ if (offset == 0.0) {
+ return;
+ }
+
float fov = camera.getFov();
float fov_range = m_fov_max - m_fov_min;
float fov_stepsize = glm::radians(fov_range) / static_cast<float>(m_fov_nsteps);
@@ -36,24 +44,18 @@ namespace vkcv::camera {
}
void PilotCameraController::panView(double xOffset, double yOffset, Camera &camera) {
- // handle yaw rotation
- float yaw = camera.getYaw() + xOffset;
- if (yaw < -180.0f) {
- yaw += 360.0f;
- }
- else if (yaw > 180.0f) {
- yaw -= 360.0f;
+ // update only if there is (valid) input
+ if (xOffset == 0.0 && yOffset == 0.0) {
+ return;
}
+
+ // handle yaw rotation
+ float yaw = camera.getYaw() + static_cast<float>(xOffset) * m_cameraSpeed;
camera.setYaw(yaw);
// handle pitch rotation
- float pitch = camera.getPitch() - yOffset;
- if (pitch > 89.0f) {
- pitch = 89.0f;
- }
- if (pitch < -89.0f) {
- pitch = -89.0f;
- }
+ float pitch = camera.getPitch() - static_cast<float>(yOffset) * m_cameraSpeed;
+ pitch = glm::clamp(pitch, -89.0f, 89.0f);
camera.setPitch(pitch);
}
@@ -70,9 +72,9 @@ namespace vkcv::camera {
const float distance = m_cameraSpeed * static_cast<float>(deltaTime);
- position += distance * getDirectionFactor(m_forward, m_backward) * front;
- position += distance * getDirectionFactor(m_left, m_right) * left;
- position += distance * getDirectionFactor(m_upward, m_downward) * up;
+ position += distance * (getDirectionFactor(m_forward, m_backward) + m_gamepadZ) * front;
+ position += distance * (getDirectionFactor(m_left, m_right) + m_gamepadX) * left;
+ position += distance * (getDirectionFactor(m_upward, m_downward) + m_gamepadY) * up;
camera.lookAt(position, position + front, up);
}
@@ -127,6 +129,39 @@ namespace vkcv::camera {
}
}
+ void PilotCameraController::gamepadCallback(int gamepadIndex, Camera &camera, double frametime) {
+ GLFWgamepadstate gamepadState;
+ glfwGetGamepadState(gamepadIndex, &gamepadState);
+
+ float sensitivity = 100.0f;
+ double threshold = 0.1;
+
+ // handle rotations
+ double stickRightX = static_cast<double>(gamepadState.axes[GLFW_GAMEPAD_AXIS_RIGHT_X]);
+ double stickRightY = static_cast<double>(gamepadState.axes[GLFW_GAMEPAD_AXIS_RIGHT_Y]);
+
+ double rightXVal = glm::clamp(std::abs(stickRightX) - threshold, 0.0, 1.0)
+ * copysign(1.0, stickRightX) * sensitivity * frametime;
+ double rightYVal = glm::clamp(std::abs(stickRightY) - threshold, 0.0, 1.0)
+ * copysign(1.0, stickRightY) * sensitivity * frametime;
+ panView(rightXVal, rightYVal, camera);
+
+ // handle zooming
+ double zoom = static_cast<double>((gamepadState.axes[GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER]
+ - gamepadState.axes[GLFW_GAMEPAD_AXIS_LEFT_TRIGGER])
+ * sensitivity * frametime);
+ changeFov(zoom, camera);
+
+ // handle translation
+ m_gamepadY = gamepadState.buttons[GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER] - gamepadState.buttons[GLFW_GAMEPAD_BUTTON_LEFT_BUMPER];
+ float stickLeftX = gamepadState.axes[GLFW_GAMEPAD_AXIS_LEFT_X];
+ float stickLeftY = gamepadState.axes[GLFW_GAMEPAD_AXIS_LEFT_Y];
+ m_gamepadZ = glm::clamp(std::abs(stickLeftY) - threshold, 0.0, 1.0)
+ * -copysign(1.0, stickLeftY);
+ m_gamepadX = glm::clamp(std::abs(stickLeftX) - threshold, 0.0, 1.0)
+ * -copysign(1.0, stickLeftX);
+ }
+
void PilotCameraController::moveForward(int action){
m_forward = static_cast<bool>(action);
diff --git a/modules/camera/src/vkcv/camera/TrackballCameraController.cpp b/modules/camera/src/vkcv/camera/TrackballCameraController.cpp
index 201c6ecdc1c703dbcd53b7dc4b179c86576f2312..b149a168f061125c08103ba63fcd7a97fa13ccc3 100644
--- a/modules/camera/src/vkcv/camera/TrackballCameraController.cpp
+++ b/modules/camera/src/vkcv/camera/TrackballCameraController.cpp
@@ -1,5 +1,4 @@
#include "vkcv/camera/TrackballCameraController.hpp"
-
#include <GLFW/glfw3.h>
namespace vkcv::camera {
@@ -9,55 +8,45 @@ namespace vkcv::camera {
m_radius = 3.0f;
m_cameraSpeed = 2.5f;
m_scrollSensitivity = 0.2f;
+ m_pitch = 0.0f;
+ m_yaw = 0.0f;
}
void TrackballCameraController::setRadius(const float radius) {
- if (radius < 0.1f) {
- m_radius = 0.1f;
- }
- else {
- m_radius = radius;
- }
+ m_radius = 0.1f * (radius < 0.1f) + radius * (1 - (radius < 0.1f));
}
void TrackballCameraController::panView(double xOffset, double yOffset, Camera &camera) {
- // handle yaw rotation
- float yaw = camera.getYaw() + xOffset * m_cameraSpeed;
- if (yaw < 0.0f) {
- yaw += 360.0f;
- }
- else if (yaw > 360.0f) {
- yaw -= 360.0f;
+ // update only if there is (valid) input
+ if (xOffset == 0.0 && yOffset == 0.0) {
+ return;
}
- camera.setYaw(yaw);
+
+ // handle yaw rotation
+ m_yaw = m_yaw + static_cast<float>(xOffset) * m_cameraSpeed;
// handle pitch rotation
- float pitch = camera.getPitch() + yOffset * m_cameraSpeed;
- if (pitch < 0.0f) {
- pitch += 360.0f;
- }
- else if (pitch > 360.0f) {
- pitch -= 360.0f;
- }
- camera.setPitch(pitch);
+ m_pitch = m_pitch + static_cast<float>(yOffset) * m_cameraSpeed;
}
void TrackballCameraController::updateRadius(double offset, Camera &camera) {
+ // update only if there is (valid) input
+ if (offset == 0.0) {
+ return;
+ }
+
glm::vec3 cameraPosition = camera.getPosition();
glm::vec3 cameraCenter = camera.getCenter();
float radius = glm::length(cameraCenter - cameraPosition); // get current camera radius
- setRadius(radius - offset * m_scrollSensitivity);
+ setRadius(radius - static_cast<float>(offset) * m_scrollSensitivity);
}
void TrackballCameraController::updateCamera(double deltaTime, Camera &camera) {
- float yaw = camera.getYaw();
- float pitch = camera.getPitch();
-
const glm::vec3 yAxis = glm::vec3(0.0f, 1.0f, 0.0f);
const glm::vec3 xAxis = glm::vec3(1.0f, 0.0f, 0.0f);
- const glm::mat4 rotationY = glm::rotate(glm::mat4(1.0f), glm::radians(yaw), yAxis);
- const glm::mat4 rotationX = glm::rotate(rotationY, -glm::radians(pitch), xAxis);
+ const glm::mat4 rotationY = glm::rotate(glm::mat4(1.0f), glm::radians(m_yaw), yAxis);
+ const glm::mat4 rotationX = glm::rotate(rotationY, -glm::radians(m_pitch), xAxis);
const glm::vec3 translation = glm::vec3(
rotationX * glm::vec4(0.0f, 0.0f, m_radius, 0.0f)
);
@@ -82,7 +71,7 @@ namespace vkcv::camera {
return;
}
- float sensitivity = 0.05f;
+ float sensitivity = 0.025f;
xoffset *= sensitivity;
yoffset *= sensitivity;
@@ -97,4 +86,28 @@ namespace vkcv::camera {
m_rotationActive = false;
}
}
+
+ void TrackballCameraController::gamepadCallback(int gamepadIndex, Camera &camera, double frametime) {
+ GLFWgamepadstate gamepadState;
+ glfwGetGamepadState(gamepadIndex, &gamepadState);
+
+ float sensitivity = 100.0f;
+ double threshold = 0.1;
+
+ // handle rotations
+ double stickRightX = static_cast<double>(gamepadState.axes[GLFW_GAMEPAD_AXIS_RIGHT_X]);
+ double stickRightY = static_cast<double>(gamepadState.axes[GLFW_GAMEPAD_AXIS_RIGHT_Y]);
+
+ double rightXVal = glm::clamp((abs(stickRightX)-threshold), 0.0, 1.0)
+ * std::copysign(1.0, stickRightX) * sensitivity * frametime;
+ double rightYVal = glm::clamp((abs(stickRightY)-threshold), 0.0, 1.0)
+ * std::copysign(1.0, stickRightY) * sensitivity * frametime;
+ panView(rightXVal, rightYVal, camera);
+
+ // handle translation
+ double stickLeftY = static_cast<double>(gamepadState.axes[GLFW_GAMEPAD_AXIS_LEFT_Y]);
+ double leftYVal = glm::clamp((abs(stickLeftY)-threshold), 0.0, 1.0)
+ * std::copysign(1.0, stickLeftY) * sensitivity * frametime;
+ updateRadius(-leftYVal, camera);
+ }
}
\ No newline at end of file
diff --git a/modules/gui/CMakeLists.txt b/modules/gui/CMakeLists.txt
index ce03f16e1f8d421f5b8e6c2fe913c0da04d34598..3b5202ccfe454f38745c53ac711cc05095ef88a1 100644
--- a/modules/gui/CMakeLists.txt
+++ b/modules/gui/CMakeLists.txt
@@ -32,3 +32,5 @@ target_include_directories(vkcv_gui SYSTEM BEFORE PRIVATE ${vkcv_gui_includes} $
# add the own include directory for public headers
target_include_directories(vkcv_gui BEFORE PUBLIC ${vkcv_gui_include} ${vkcv_imgui_includes})
+
+target_compile_definitions(vkcv_gui PUBLIC ${vkcv_gui_defines})
diff --git a/modules/gui/config/ImGui.cmake b/modules/gui/config/ImGui.cmake
index 3f55ad05c34783ba0e82c41d2cbc4e5b204d60e7..90cdafdeee355af9e63723632572799e135b04da 100644
--- a/modules/gui/config/ImGui.cmake
+++ b/modules/gui/config/ImGui.cmake
@@ -1,17 +1,27 @@
if (EXISTS "${vkcv_gui_lib_path}/imgui")
list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/backends/imgui_impl_glfw.cpp)
- list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/backends/imgui_impl_vulkan.cpp )
+ list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/backends/imgui_impl_glfw.h)
+ list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/backends/imgui_impl_vulkan.cpp)
+ list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/backends/imgui_impl_vulkan.h)
+ list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imconfig.h)
list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imgui.cpp)
+ list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imgui.h)
list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imgui_draw.cpp)
list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imgui_demo.cpp)
+ list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imgui_internal.h)
list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imgui_tables.cpp)
list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imgui_widgets.cpp)
+ list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imstb_rectpack.h)
+ list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imstb_textedit.h)
+ list(APPEND vkcv_imgui_sources ${vkcv_gui_lib_path}/imgui/imstb_truetype.h)
list(APPEND vkcv_imgui_includes ${vkcv_gui_lib}/imgui)
list(APPEND vkcv_imgui_includes ${vkcv_gui_lib}/imgui/backend)
list(APPEND vkcv_gui_include ${vkcv_gui_lib})
+
+ list(APPEND vkcv_gui_defines IMGUI_DISABLE_WIN32_FUNCTIONS=1)
else()
message(WARNING "IMGUI is required..! Update the submodules!")
endif ()
diff --git a/modules/gui/src/vkcv/gui/GUI.cpp b/modules/gui/src/vkcv/gui/GUI.cpp
index a9a8bd01df379a0f4615c2c53aee09082d107b1c..38bb6894fb2b40c6ab10445f19431f87f7370afc 100644
--- a/modules/gui/src/vkcv/gui/GUI.cpp
+++ b/modules/gui/src/vkcv/gui/GUI.cpp
@@ -73,13 +73,13 @@ namespace vkcv::gui {
);
ImGui_ImplVulkan_InitInfo init_info = {};
- init_info.Instance = m_context.getInstance();
- init_info.PhysicalDevice = m_context.getPhysicalDevice();
- init_info.Device = m_context.getDevice();
+ init_info.Instance = static_cast<VkInstance>(m_context.getInstance());
+ init_info.PhysicalDevice = static_cast<VkPhysicalDevice>(m_context.getPhysicalDevice());
+ init_info.Device = static_cast<VkDevice>(m_context.getDevice());
init_info.QueueFamily = graphicsQueueFamilyIndex;
- init_info.Queue = m_context.getQueueManager().getGraphicsQueues()[0].handle;
- init_info.PipelineCache = nullptr;
- init_info.DescriptorPool = m_descriptor_pool;
+ init_info.Queue = static_cast<VkQueue>(m_context.getQueueManager().getGraphicsQueues()[0].handle);
+ init_info.PipelineCache = 0;
+ init_info.DescriptorPool = static_cast<VkDescriptorPool>(m_descriptor_pool);
init_info.Allocator = nullptr;
init_info.MinImageCount = swapchain.getImageCount();
init_info.ImageCount = swapchain.getImageCount();
@@ -137,12 +137,12 @@ namespace vkcv::gui {
m_render_pass = m_context.getDevice().createRenderPass(passCreateInfo);
- ImGui_ImplVulkan_Init(&init_info, m_render_pass);
+ ImGui_ImplVulkan_Init(&init_info, static_cast<VkRenderPass>(m_render_pass));
const SubmitInfo submitInfo { QueueType::Graphics, {}, {} };
m_core.recordAndSubmitCommandsImmediate(submitInfo, [](const vk::CommandBuffer& commandBuffer) {
- ImGui_ImplVulkan_CreateFontsTexture(commandBuffer);
+ ImGui_ImplVulkan_CreateFontsTexture(static_cast<VkCommandBuffer>(commandBuffer));
}, []() {
ImGui_ImplVulkan_DestroyFontUploadObjects();
});
@@ -230,7 +230,7 @@ namespace vkcv::gui {
commandBuffer.beginRenderPass(beginInfo, vk::SubpassContents::eInline);
- ImGui_ImplVulkan_RenderDrawData(drawData, commandBuffer);
+ ImGui_ImplVulkan_RenderDrawData(drawData, static_cast<VkCommandBuffer>(commandBuffer));
commandBuffer.endRenderPass();
}, [&]() {
diff --git a/modules/material/CMakeLists.txt b/modules/material/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ed3804531d36f9850bbb5d334e4fed9b43d92434
--- /dev/null
+++ b/modules/material/CMakeLists.txt
@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.16)
+project(vkcv_material)
+
+# setting c++ standard for the module
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(vkcv_material_source ${PROJECT_SOURCE_DIR}/src)
+set(vkcv_material_include ${PROJECT_SOURCE_DIR}/include)
+
+# Add source and header files to the module
+set(vkcv_material_sources
+ ${vkcv_material_include}/vkcv/material/Material.hpp
+ ${vkcv_material_source}/vkcv/material/Material.cpp
+)
+
+# adding source files to the module
+add_library(vkcv_material STATIC ${vkcv_material_sources})
+
+# link the required libraries to the module
+target_link_libraries(vkcv_material vkcv ${vkcv_libraries})
+
+# including headers of dependencies and the VkCV framework
+target_include_directories(vkcv_material SYSTEM BEFORE PRIVATE ${vkcv_include} ${vkcv_includes})
+
+# add the own include directory for public headers
+target_include_directories(vkcv_material BEFORE PUBLIC ${vkcv_material_include})
diff --git a/modules/material/include/vkcv/material/Material.hpp b/modules/material/include/vkcv/material/Material.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..9b54d99828eca3738fed9ff1c4078ca9f87eaefa
--- /dev/null
+++ b/modules/material/include/vkcv/material/Material.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <vector>
+
+#include <vkcv/Core.hpp>
+#include <vkcv/Handles.hpp>
+
+namespace vkcv::material {
+
+ enum class MaterialType {
+ PBR_MATERIAL = 1,
+
+ UNKNOWN = 0
+ };
+
+ class Material {
+ private:
+ struct Texture {
+ ImageHandle m_Image;
+ SamplerHandle m_Sampler;
+ std::vector<float> m_Factors;
+ };
+
+ MaterialType m_Type;
+ DescriptorSetHandle m_DescriptorSet;
+ std::vector<Texture> m_Textures;
+
+ public:
+ Material();
+ ~Material() = default;
+
+ Material(const Material& other) = default;
+ Material(Material&& other) = default;
+
+ Material& operator=(const Material& other) = default;
+ Material& operator=(Material&& other) = default;
+
+ [[nodiscard]]
+ MaterialType getType() const;
+
+ [[nodiscard]]
+ const DescriptorSetHandle& getDescriptorSet() const;
+
+ explicit operator bool() const;
+
+ bool operator!() const;
+
+ static const std::vector<DescriptorBinding>& getDescriptorBindings(MaterialType type);
+
+ static Material createPBR(Core &core,
+ const ImageHandle &colorImg,
+ const SamplerHandle &colorSmp,
+ const ImageHandle &normalImg,
+ const SamplerHandle &normalSmp,
+ const ImageHandle &metRoughImg,
+ const SamplerHandle &metRoughSmp,
+ const ImageHandle &occlusionImg,
+ const SamplerHandle &occlusionSmp,
+ const ImageHandle &emissiveImg,
+ const SamplerHandle &emissiveSmp,
+ const float baseColorFactor [4],
+ float metallicFactor,
+ float roughnessFactor,
+ float normalScale,
+ float occlusionStrength,
+ const float emissiveFactor [3]);
+
+ };
+
+}
diff --git a/modules/material/src/vkcv/material/Material.cpp b/modules/material/src/vkcv/material/Material.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..409db0b9dd83f91b6a2afbb48d74933ab1a483fc
--- /dev/null
+++ b/modules/material/src/vkcv/material/Material.cpp
@@ -0,0 +1,186 @@
+
+#include "vkcv/material/Material.hpp"
+
+namespace vkcv::material {
+
+ Material::Material() {
+ m_Type = MaterialType::UNKNOWN;
+ }
+
+ MaterialType Material::getType() const {
+ return m_Type;
+ }
+
+ const DescriptorSetHandle & Material::getDescriptorSet() const {
+ return m_DescriptorSet;
+ }
+
+ Material::operator bool() const {
+ return (m_Type != MaterialType::UNKNOWN);
+ }
+
+ bool Material::operator!() const {
+ return (m_Type == MaterialType::UNKNOWN);
+ }
+
+ const std::vector<DescriptorBinding>& Material::getDescriptorBindings(MaterialType type)
+ {
+ static std::vector<DescriptorBinding> pbr_bindings;
+ static std::vector<DescriptorBinding> default_bindings;
+
+ switch (type) {
+ case MaterialType::PBR_MATERIAL:
+ if (pbr_bindings.empty()) {
+ pbr_bindings.emplace_back(0, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+ pbr_bindings.emplace_back(1, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+ pbr_bindings.emplace_back(2, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+ pbr_bindings.emplace_back(3, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+ pbr_bindings.emplace_back(4, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+ pbr_bindings.emplace_back(5, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+ pbr_bindings.emplace_back(6, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+ pbr_bindings.emplace_back(7, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+ pbr_bindings.emplace_back(8, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+ pbr_bindings.emplace_back(9, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+ }
+
+ return pbr_bindings;
+ default:
+ return default_bindings;
+ }
+ }
+
+ static void fillImage(Image& image, float data [4]) {
+ std::vector<float> vec (image.getWidth() * image.getHeight() * image.getDepth() * 4);
+
+ for (size_t i = 0; i < vec.size(); i++) {
+ vec[i] = data[i % 4];
+ }
+
+ image.fill(data);
+ }
+
+ Material Material::createPBR(Core &core,
+ const ImageHandle &colorImg, const SamplerHandle &colorSmp,
+ const ImageHandle &normalImg, const SamplerHandle &normalSmp,
+ const ImageHandle &metRoughImg, const SamplerHandle &metRoughSmp,
+ const ImageHandle &occlusionImg, const SamplerHandle &occlusionSmp,
+ const ImageHandle &emissiveImg, const SamplerHandle &emissiveSmp,
+ const float baseColorFactor [4],
+ float metallicFactor,
+ float roughnessFactor,
+ float normalScale,
+ float occlusionStrength,
+ const float emissiveFactor [3]) {
+ ImageHandle images [5] = {
+ colorImg, normalImg, metRoughImg, occlusionImg, emissiveImg
+ };
+
+ SamplerHandle samplers [5] = {
+ colorSmp, normalSmp, metRoughSmp, occlusionSmp, emissiveSmp
+ };
+
+ if (!colorImg) {
+ vkcv::Image defaultColor = core.createImage(vk::Format::eR8G8B8A8Srgb, 2, 2);
+ float colorData [4] = { 228, 51, 255, 1 };
+ fillImage(defaultColor, colorData);
+ images[0] = defaultColor.getHandle();
+ }
+
+ if (!normalImg) {
+ vkcv::Image defaultNormal = core.createImage(vk::Format::eR8G8B8A8Srgb, 2, 2);
+ float normalData [4] = { 0, 0, 1, 0 };
+ fillImage(defaultNormal, normalData);
+ images[1] = defaultNormal.getHandle();
+ }
+
+ if (!metRoughImg) {
+ vkcv::Image defaultRough = core.createImage(vk::Format::eR8G8B8A8Srgb, 2, 2);
+ float roughData [4] = { 228, 51, 255, 1 };
+ fillImage(defaultRough, roughData);
+ images[2] = defaultRough.getHandle();
+ }
+
+ if (!occlusionImg) {
+ vkcv::Image defaultOcclusion = core.createImage(vk::Format::eR8G8B8A8Srgb, 2, 2);
+ float occlusionData [4] = { 228, 51, 255, 1 };
+ fillImage(defaultOcclusion, occlusionData);
+ images[3] = defaultOcclusion.getHandle();
+ }
+
+ if (!emissiveImg) {
+ vkcv::Image defaultEmissive = core.createImage(vk::Format::eR8G8B8A8Srgb, 2, 2);
+ float emissiveData [4] = { 0, 0, 0, 1 };
+ fillImage(defaultEmissive, emissiveData);
+ images[4] = defaultEmissive.getHandle();
+ }
+
+ if (!colorSmp) {
+ samplers[0] = core.createSampler(
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::REPEAT
+ );
+ }
+
+ if (!normalSmp) {
+ samplers[1] = core.createSampler(
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::REPEAT
+ );
+ }
+
+ if (!metRoughSmp) {
+ samplers[2] = core.createSampler(
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::REPEAT
+ );
+ }
+
+ if (!occlusionSmp) {
+ samplers[3] = core.createSampler(
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::REPEAT
+ );
+ }
+
+ if (!emissiveSmp) {
+ samplers[4] = core.createSampler(
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::REPEAT
+ );
+ }
+
+ Material material;
+ material.m_Type = MaterialType::PBR_MATERIAL;
+
+ const auto& bindings = getDescriptorBindings(material.m_Type);
+ material.m_DescriptorSet = core.createDescriptorSet(bindings);;
+
+ material.m_Textures.reserve(bindings.size());
+ material.m_Textures.push_back({ images[0], samplers[0], std::vector<float>(baseColorFactor, baseColorFactor+4) });
+ material.m_Textures.push_back({ images[1], samplers[1], { normalScale } });
+ material.m_Textures.push_back({ images[2], samplers[2], { metallicFactor, roughnessFactor } });
+ material.m_Textures.push_back({ images[3], samplers[3], { occlusionStrength } });
+ material.m_Textures.push_back({ images[4], samplers[4], std::vector<float>(emissiveFactor, emissiveFactor+3) });
+
+ vkcv::DescriptorWrites setWrites;
+
+ for (size_t i = 0; i < material.m_Textures.size(); i++) {
+ setWrites.sampledImageWrites.emplace_back(i * 2, material.m_Textures[i].m_Image);
+ setWrites.samplerWrites.emplace_back(i * 2 + 1, material.m_Textures[i].m_Sampler);
+ }
+
+ core.writeDescriptorSet(material.m_DescriptorSet, setWrites);
+ return material;
+ }
+
+}
diff --git a/modules/scene/CMakeLists.txt b/modules/scene/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9aa76883a260d26aa6f46d6dabdc8206e4dad387
--- /dev/null
+++ b/modules/scene/CMakeLists.txt
@@ -0,0 +1,45 @@
+cmake_minimum_required(VERSION 3.16)
+project(vkcv_scene)
+
+# setting c++ standard for the module
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(vkcv_scene_source ${PROJECT_SOURCE_DIR}/src)
+set(vkcv_scene_include ${PROJECT_SOURCE_DIR}/include)
+
+# Add source and header files to the module
+set(vkcv_scene_sources
+ ${vkcv_scene_include}/vkcv/scene/Bounds.hpp
+ ${vkcv_scene_source}/vkcv/scene/Bounds.cpp
+
+ ${vkcv_scene_source}/vkcv/scene/Frustum.hpp
+ ${vkcv_scene_source}/vkcv/scene/Frustum.cpp
+
+ ${vkcv_scene_include}/vkcv/scene/MeshPart.hpp
+ ${vkcv_scene_source}/vkcv/scene/MeshPart.cpp
+
+ ${vkcv_scene_include}/vkcv/scene/Mesh.hpp
+ ${vkcv_scene_source}/vkcv/scene/Mesh.cpp
+
+ ${vkcv_scene_include}/vkcv/scene/Node.hpp
+ ${vkcv_scene_source}/vkcv/scene/Node.cpp
+
+ ${vkcv_scene_include}/vkcv/scene/Scene.hpp
+ ${vkcv_scene_source}/vkcv/scene/Scene.cpp
+)
+
+# adding source files to the module
+add_library(vkcv_scene STATIC ${vkcv_scene_sources})
+
+# link the required libraries to the module
+target_link_libraries(vkcv_scene vkcv)
+
+# including headers of dependencies and the VkCV framework
+target_include_directories(vkcv_scene SYSTEM BEFORE PRIVATE ${vkcv_include} ${vkcv_includes} ${vkcv_asset_loader_include} ${vkcv_material_include} ${vkcv_camera_include})
+
+# add the own include directory for public headers
+target_include_directories(vkcv_scene BEFORE PUBLIC ${vkcv_scene_include})
+
+# linking with libraries from all dependencies and the VkCV framework
+target_link_libraries(vkcv_scene vkcv vkcv_asset_loader vkcv_material vkcv_camera)
\ No newline at end of file
diff --git a/modules/scene/include/vkcv/scene/Bounds.hpp b/modules/scene/include/vkcv/scene/Bounds.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..07cdf88828d786982b0fe8e7919d543557794c42
--- /dev/null
+++ b/modules/scene/include/vkcv/scene/Bounds.hpp
@@ -0,0 +1,69 @@
+#pragma once
+
+#include <array>
+#include <iostream>
+#include <glm/vec3.hpp>
+
+namespace vkcv::scene {
+
+ class Bounds {
+ private:
+ glm::vec3 m_min;
+ glm::vec3 m_max;
+
+ public:
+ Bounds();
+ Bounds(const glm::vec3& min, const glm::vec3& max);
+ ~Bounds() = default;
+
+ Bounds(const Bounds& other) = default;
+ Bounds(Bounds&& other) = default;
+
+ Bounds& operator=(const Bounds& other) = default;
+ Bounds& operator=(Bounds&& other) = default;
+
+ void setMin(const glm::vec3& min);
+
+ [[nodiscard]]
+ const glm::vec3& getMin() const;
+
+ void setMax(const glm::vec3& max);
+
+ [[nodiscard]]
+ const glm::vec3& getMax() const;
+
+ void setCenter(const glm::vec3& center);
+
+ [[nodiscard]]
+ glm::vec3 getCenter() const;
+
+ void setSize(const glm::vec3& size);
+
+ [[nodiscard]]
+ glm::vec3 getSize() const;
+
+ [[nodiscard]]
+ std::array<glm::vec3, 8> getCorners() const;
+
+ void extend(const glm::vec3& point);
+
+ [[nodiscard]]
+ bool contains(const glm::vec3& point) const;
+
+ [[nodiscard]]
+ bool contains(const Bounds& other) const;
+
+ [[nodiscard]]
+ bool intersects(const Bounds& other) const;
+
+ [[nodiscard]]
+ explicit operator bool() const;
+
+ [[nodiscard]]
+ bool operator!() const;
+
+ };
+
+ std::ostream& operator << (std::ostream& out, const Bounds& bounds);
+
+}
diff --git a/modules/scene/include/vkcv/scene/Mesh.hpp b/modules/scene/include/vkcv/scene/Mesh.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc82af4bfabed5e8bfc286bc53cd7b89791726fc
--- /dev/null
+++ b/modules/scene/include/vkcv/scene/Mesh.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <glm/mat4x4.hpp>
+
+#include <vkcv/camera/Camera.hpp>
+
+#include "MeshPart.hpp"
+
+namespace vkcv::scene {
+
+ typedef typename event_function<const glm::mat4&, const glm::mat4&, PushConstants&, vkcv::DrawcallInfo&>::type RecordMeshDrawcallFunction;
+
+ class Node;
+
+ class Mesh {
+ friend class Node;
+
+ private:
+ Scene& m_scene;
+ std::vector<MeshPart> m_parts;
+ std::vector<DrawcallInfo> m_drawcalls;
+ glm::mat4 m_transform;
+ Bounds m_bounds;
+
+ explicit Mesh(Scene& scene);
+
+ void load(const asset::Scene& scene,
+ const asset::Mesh& mesh);
+
+ void recordDrawcalls(const glm::mat4& viewProjection,
+ PushConstants& pushConstants,
+ std::vector<DrawcallInfo>& drawcalls,
+ const RecordMeshDrawcallFunction& record);
+
+ [[nodiscard]]
+ size_t getDrawcallCount() const;
+
+ public:
+ ~Mesh();
+
+ Mesh(const Mesh& other) = default;
+ Mesh(Mesh&& other) = default;
+
+ Mesh& operator=(const Mesh& other);
+ Mesh& operator=(Mesh&& other) noexcept;
+
+ [[nodiscard]]
+ const Bounds& getBounds() const;
+
+ };
+
+}
diff --git a/modules/scene/include/vkcv/scene/MeshPart.hpp b/modules/scene/include/vkcv/scene/MeshPart.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0d3467c6b57fcece69eb6f0c609c604fb99907d2
--- /dev/null
+++ b/modules/scene/include/vkcv/scene/MeshPart.hpp
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <vector>
+
+#include <vkcv/Buffer.hpp>
+#include <vkcv/asset/asset_loader.hpp>
+#include <vkcv/material/Material.hpp>
+
+#include "Bounds.hpp"
+
+namespace vkcv::scene {
+
+ class Scene;
+ class Mesh;
+
+ class MeshPart {
+ friend class Mesh;
+
+ private:
+ Scene& m_scene;
+ BufferHandle m_vertices;
+ std::vector<VertexBufferBinding> m_vertexBindings;
+ BufferHandle m_indices;
+ size_t m_indexCount;
+ Bounds m_bounds;
+ size_t m_materialIndex;
+
+ explicit MeshPart(Scene& scene);
+
+ void load(const asset::Scene& scene,
+ const asset::VertexGroup& vertexGroup,
+ std::vector<DrawcallInfo>& drawcalls);
+
+ public:
+ ~MeshPart();
+
+ MeshPart(const MeshPart& other);
+ MeshPart(MeshPart&& other);
+
+ MeshPart& operator=(const MeshPart& other);
+ MeshPart& operator=(MeshPart&& other) noexcept;
+
+ [[nodiscard]]
+ const material::Material& getMaterial() const;
+
+ [[nodiscard]]
+ const Bounds& getBounds() const;
+
+ explicit operator bool() const;
+ bool operator!() const;
+
+ };
+
+}
diff --git a/modules/scene/include/vkcv/scene/Node.hpp b/modules/scene/include/vkcv/scene/Node.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1fcca5b9cbecf1064070d7737d008d2b108371db
--- /dev/null
+++ b/modules/scene/include/vkcv/scene/Node.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <vector>
+
+#include <vkcv/camera/Camera.hpp>
+
+#include "Bounds.hpp"
+#include "Mesh.hpp"
+
+namespace vkcv::scene {
+
+ class Scene;
+
+ class Node {
+ friend class Scene;
+
+ private:
+ Scene& m_scene;
+
+ std::vector<Mesh> m_meshes;
+ std::vector<Node> m_nodes;
+ Bounds m_bounds;
+
+ explicit Node(Scene& scene);
+
+ void addMesh(const Mesh& mesh);
+
+ void loadMesh(const asset::Scene& asset_scene, const asset::Mesh& asset_mesh);
+
+ void recordDrawcalls(const glm::mat4& viewProjection,
+ PushConstants& pushConstants,
+ std::vector<DrawcallInfo>& drawcalls,
+ const RecordMeshDrawcallFunction& record);
+
+ void splitMeshesToSubNodes(size_t maxMeshesPerNode);
+
+ [[nodiscard]]
+ size_t getDrawcallCount() const;
+
+ size_t addNode();
+
+ Node& getNode(size_t index);
+
+ [[nodiscard]]
+ const Node& getNode(size_t index) const;
+
+ public:
+ ~Node();
+
+ Node(const Node& other) = default;
+ Node(Node&& other) = default;
+
+ Node& operator=(const Node& other);
+ Node& operator=(Node&& other) noexcept;
+
+ [[nodiscard]]
+ const Bounds& getBounds() const;
+
+ };
+
+}
diff --git a/modules/scene/include/vkcv/scene/Scene.hpp b/modules/scene/include/vkcv/scene/Scene.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..429c0bcf729f9afb7dd76cdd58c54931862e1a4a
--- /dev/null
+++ b/modules/scene/include/vkcv/scene/Scene.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <filesystem>
+#include <mutex>
+
+#include <vkcv/Core.hpp>
+#include <vkcv/Event.hpp>
+#include <vkcv/camera/Camera.hpp>
+#include <vkcv/material/Material.hpp>
+
+#include "Node.hpp"
+
+namespace vkcv::scene {
+
+ class Scene {
+ friend class MeshPart;
+
+ private:
+ struct Material {
+ size_t m_usages;
+ material::Material m_data;
+ };
+
+ Core* m_core;
+
+ std::vector<Material> m_materials;
+ std::vector<Node> m_nodes;
+
+ explicit Scene(Core* core);
+
+ size_t addNode();
+
+ Node& getNode(size_t index);
+
+ const Node& getNode(size_t index) const;
+
+ void increaseMaterialUsage(size_t index);
+
+ void decreaseMaterialUsage(size_t index);
+
+ void loadMaterial(size_t index, const asset::Scene& scene,
+ const asset::Material& material);
+
+ public:
+ ~Scene();
+
+ Scene(const Scene& other);
+ Scene(Scene&& other) noexcept;
+
+ Scene& operator=(const Scene& other);
+ Scene& operator=(Scene&& other) noexcept;
+
+ size_t getMaterialCount() const;
+
+ [[nodiscard]]
+ const material::Material& getMaterial(size_t index) const;
+
+ void recordDrawcalls(CommandStreamHandle &cmdStream,
+ const camera::Camera &camera,
+ const PassHandle &pass,
+ const PipelineHandle &pipeline,
+ size_t pushConstantsSizePerDrawcall,
+ const RecordMeshDrawcallFunction &record,
+ const std::vector<ImageHandle> &renderTargets);
+
+ static Scene create(Core& core);
+
+ static Scene load(Core& core, const std::filesystem::path &path);
+
+ };
+
+}
\ No newline at end of file
diff --git a/modules/scene/src/vkcv/scene/Bounds.cpp b/modules/scene/src/vkcv/scene/Bounds.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..731d81e928deae4c27f5c857de5b94dc3180888b
--- /dev/null
+++ b/modules/scene/src/vkcv/scene/Bounds.cpp
@@ -0,0 +1,126 @@
+
+#include "vkcv/scene/Bounds.hpp"
+
+namespace vkcv::scene {
+
+ Bounds::Bounds() :
+ m_min(glm::vec3(0)),
+ m_max(glm::vec3(0)) {}
+
+ Bounds::Bounds(const glm::vec3 &min, const glm::vec3 &max) :
+ m_min(min),
+ m_max(max)
+ {}
+
+ void Bounds::setMin(const glm::vec3 &min) {
+ m_min = min;
+ }
+
+ const glm::vec3 & Bounds::getMin() const {
+ return m_min;
+ }
+
+ void Bounds::setMax(const glm::vec3 &max) {
+ m_max = max;
+ }
+
+ const glm::vec3 & Bounds::getMax() const {
+ return m_max;
+ }
+
+ void Bounds::setCenter(const glm::vec3 ¢er) {
+ const glm::vec3 size = getSize();
+ m_min = center - size / 2.0f;
+ m_max = center + size / 2.0f;
+ }
+
+ glm::vec3 Bounds::getCenter() const {
+ return (m_min + m_max) / 2.0f;
+ }
+
+ void Bounds::setSize(const glm::vec3 &size) {
+ const glm::vec3 center = getCenter();
+ m_min = center - size / 2.0f;
+ m_max = center + size / 2.0f;
+ }
+
+ glm::vec3 Bounds::getSize() const {
+ return (m_max - m_min);
+ }
+
+ std::array<glm::vec3, 8> Bounds::getCorners() const {
+ return {
+ m_min,
+ glm::vec3(m_min[0], m_min[1], m_max[2]),
+ glm::vec3(m_min[0], m_max[1], m_min[2]),
+ glm::vec3(m_min[0], m_max[1], m_max[2]),
+ glm::vec3(m_max[0], m_min[1], m_min[2]),
+ glm::vec3(m_max[0], m_min[1], m_max[2]),
+ glm::vec3(m_max[0], m_max[1], m_min[2]),
+ m_max
+ };
+ }
+
+ void Bounds::extend(const glm::vec3 &point) {
+ m_min = glm::vec3(
+ std::min(m_min[0], point[0]),
+ std::min(m_min[1], point[1]),
+ std::min(m_min[2], point[2])
+ );
+
+ m_max = glm::vec3(
+ std::max(m_max[0], point[0]),
+ std::max(m_max[1], point[1]),
+ std::max(m_max[2], point[2])
+ );
+ }
+
+ bool Bounds::contains(const glm::vec3 &point) const {
+ return (
+ (point[0] >= m_min[0]) && (point[0] <= m_max[0]) &&
+ (point[1] >= m_min[1]) && (point[1] <= m_max[1]) &&
+ (point[2] >= m_min[2]) && (point[2] <= m_max[2])
+ );
+ }
+
+ bool Bounds::contains(const Bounds &other) const {
+ return (
+ (other.m_min[0] >= m_min[0]) && (other.m_max[0] <= m_max[0]) &&
+ (other.m_min[1] >= m_min[1]) && (other.m_max[1] <= m_max[1]) &&
+ (other.m_min[2] >= m_min[2]) && (other.m_max[2] <= m_max[2])
+ );
+ }
+
+ bool Bounds::intersects(const Bounds &other) const {
+ return (
+ (other.m_max[0] >= m_min[0]) && (other.m_min[0] <= m_max[0]) &&
+ (other.m_max[1] >= m_min[1]) && (other.m_min[1] <= m_max[1]) &&
+ (other.m_max[2] >= m_min[2]) && (other.m_min[2] <= m_max[2])
+ );
+ }
+
+ Bounds::operator bool() const {
+ return (
+ (m_min[0] <= m_max[0]) &&
+ (m_min[1] <= m_max[1]) &&
+ (m_min[2] <= m_max[2])
+ );
+ }
+
+ bool Bounds::operator!() const {
+ return (
+ (m_min[0] > m_max[0]) ||
+ (m_min[1] > m_max[1]) ||
+ (m_min[2] > m_max[2])
+ );
+ }
+
+ std::ostream& operator << (std::ostream& out, const Bounds& bounds) {
+ const auto& min = bounds.getMin();
+ const auto& max = bounds.getMax();
+
+ return out << "[Bounds: (" << min[0] << ", " << min[1] << ", " << min[2] << ") ("
+ << max[0] << ", " << max[1] << ", " << max[2] << ") ]";
+ }
+
+}
diff --git a/modules/scene/src/vkcv/scene/Frustum.cpp b/modules/scene/src/vkcv/scene/Frustum.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c800bb1e4baf4d0feef33c073740fb211da7bf63
--- /dev/null
+++ b/modules/scene/src/vkcv/scene/Frustum.cpp
@@ -0,0 +1,73 @@
+
+#include "Frustum.hpp"
+
+namespace vkcv::scene {
+
+ static glm::vec3 transformPoint(const glm::mat4& transform, const glm::vec3& point, bool* negative_w) {
+ const glm::vec4 position = transform * glm::vec4(point, 1.0f);
+
+
+ /*
+ * We divide by the absolute of the 4th coorditnate because
+ * clipping is weird and points have to move to the other
+ * side of the camera.
+ *
+ * We also need to collect if the 4th coordinate was negative
+ * to know if all corners are behind the camera. So these can
+ * be culled as well
+ */
+ if (negative_w) {
+ const float perspective = std::abs(position[3]);
+
+ *negative_w &= (position[3] < 0.0f);
+
+ return glm::vec3(
+ position[0] / perspective,
+ position[1] / perspective,
+ position[2] / perspective
+ );
+ } else {
+ return glm::vec3(
+ position[0],
+ position[1],
+ position[2]
+ );
+ }
+ }
+
+ Bounds transformBounds(const glm::mat4& transform, const Bounds& bounds, bool* negative_w) {
+ const auto corners = bounds.getCorners();
+
+ if (negative_w) {
+ *negative_w = true;
+ }
+
+ auto projected = transformPoint(transform, corners[0], negative_w);
+
+ Bounds result (projected, projected);
+
+ for (size_t j = 1; j < corners.size(); j++) {
+ projected = transformPoint(transform, corners[j], negative_w);
+ result.extend(projected);
+ }
+
+ return result;
+ }
+
+ bool checkFrustum(const glm::mat4& transform, const Bounds& bounds) {
+ static Bounds frustum (
+ glm::vec3(-1.0f, -1.0f, -0.0f),
+ glm::vec3(+1.0f, +1.0f, +1.0f)
+ );
+
+ bool negative_w;
+ auto box = transformBounds(transform, bounds, &negative_w);
+
+ if (negative_w) {
+ return false;
+ } else {
+ return box.intersects(frustum);
+ }
+ }
+
+}
diff --git a/modules/scene/src/vkcv/scene/Frustum.hpp b/modules/scene/src/vkcv/scene/Frustum.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..de3917575a9aed32459e6403fab1d6d8fe131b0a
--- /dev/null
+++ b/modules/scene/src/vkcv/scene/Frustum.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <glm/mat4x4.hpp>
+#include "vkcv/scene/Bounds.hpp"
+
+namespace vkcv::scene {
+
+ Bounds transformBounds(const glm::mat4& transform, const Bounds& bounds, bool* negative_w = nullptr);
+
+ bool checkFrustum(const glm::mat4& transform, const Bounds& bounds);
+
+}
diff --git a/modules/scene/src/vkcv/scene/Mesh.cpp b/modules/scene/src/vkcv/scene/Mesh.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53fb81713ed7e14049a21cb91c771d67f2f7086c
--- /dev/null
+++ b/modules/scene/src/vkcv/scene/Mesh.cpp
@@ -0,0 +1,132 @@
+
+#include "vkcv/scene/Mesh.hpp"
+#include "vkcv/scene/Scene.hpp"
+#include "Frustum.hpp"
+
+namespace vkcv::scene {
+
+ Mesh::Mesh(Scene& scene) :
+ m_scene(scene) {}
+
+ static glm::mat4 arrayTo4x4Matrix(const std::array<float,16>& array){
+ glm::mat4 matrix;
+
+ for (int i = 0; i < 4; i++){
+ for (int j = 0; j < 4; j++){
+ matrix[i][j] = array[j * 4 + i];
+ }
+ }
+
+ return matrix;
+ }
+
+ void Mesh::load(const asset::Scene &scene, const asset::Mesh &mesh) {
+ m_parts.clear();
+ m_drawcalls.clear();
+
+ m_transform = arrayTo4x4Matrix(mesh.modelMatrix);
+
+ for (const auto& vertexGroupIndex : mesh.vertexGroups) {
+ if ((vertexGroupIndex < 0) || (vertexGroupIndex >= scene.vertexGroups.size())) {
+ continue;
+ }
+
+ MeshPart part (m_scene);
+ part.load(scene, scene.vertexGroups[vertexGroupIndex], m_drawcalls);
+
+ if (!part) {
+ continue;
+ }
+
+ auto bounds = transformBounds(m_transform, part.getBounds());
+
+ if (m_parts.empty()) {
+ m_bounds = bounds;
+ } else {
+ m_bounds.extend(bounds.getMin());
+ m_bounds.extend(bounds.getMax());
+ }
+
+ m_parts.push_back(part);
+ }
+ }
+
+ Mesh::~Mesh() {
+ m_drawcalls.clear();
+ m_parts.clear();
+ }
+
+ Mesh &Mesh::operator=(const Mesh &other) {
+ if (&other == this) {
+ return *this;
+ }
+
+ m_parts.resize(other.m_parts.size(), MeshPart(m_scene));
+
+ for (size_t i = 0; i < m_parts.size(); i++) {
+ m_parts[i] = other.m_parts[i];
+ }
+
+ m_drawcalls = std::vector<DrawcallInfo>(other.m_drawcalls);
+ m_transform = other.m_transform;
+ m_bounds = other.m_bounds;
+
+ return *this;
+ }
+
+ Mesh &Mesh::operator=(Mesh &&other) noexcept {
+ m_parts.resize(other.m_parts.size(), MeshPart(m_scene));
+
+ for (size_t i = 0; i < m_parts.size(); i++) {
+ m_parts[i] = std::move(other.m_parts[i]);
+ }
+
+ m_drawcalls = std::move(other.m_drawcalls);
+ m_transform = other.m_transform;
+ m_bounds = other.m_bounds;
+
+ return *this;
+ }
+
+ void Mesh::recordDrawcalls(const glm::mat4& viewProjection,
+ PushConstants& pushConstants,
+ std::vector<DrawcallInfo>& drawcalls,
+ const RecordMeshDrawcallFunction& record) {
+ const glm::mat4 transform = viewProjection * m_transform;
+
+ if (!checkFrustum(viewProjection, m_bounds)) {
+ return;
+ }
+
+ if (m_drawcalls.size() == 1) {
+ drawcalls.push_back(m_drawcalls[0]);
+
+ if (record) {
+ record(transform, m_transform, pushConstants, drawcalls.back());
+ }
+ } else {
+ for (size_t i = 0; i < m_parts.size(); i++) {
+ const MeshPart& part = m_parts[i];
+
+ if (!checkFrustum(transform, part.getBounds())) {
+ continue;
+ }
+
+ drawcalls.push_back(m_drawcalls[i]);
+
+ if (record) {
+ record(transform, m_transform, pushConstants, drawcalls.back());
+ }
+ }
+ }
+ }
+
+ size_t Mesh::getDrawcallCount() const {
+ return m_drawcalls.size();
+ }
+
+ const Bounds& Mesh::getBounds() const {
+ return m_bounds;
+ }
+
+}
diff --git a/modules/scene/src/vkcv/scene/MeshPart.cpp b/modules/scene/src/vkcv/scene/MeshPart.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..46e79897719d5422151ec31837a41f7e58324a71
--- /dev/null
+++ b/modules/scene/src/vkcv/scene/MeshPart.cpp
@@ -0,0 +1,158 @@
+
+#include "vkcv/scene/MeshPart.hpp"
+#include "vkcv/scene/Scene.hpp"
+
+namespace vkcv::scene {
+
+ MeshPart::MeshPart(Scene& scene) :
+ m_scene(scene),
+ m_vertices(),
+ m_vertexBindings(),
+ m_indices(),
+ m_indexCount(0),
+ m_bounds(),
+ m_materialIndex(std::numeric_limits<size_t>::max()) {}
+
+ void MeshPart::load(const asset::Scene& scene,
+ const asset::VertexGroup &vertexGroup,
+ std::vector<DrawcallInfo>& drawcalls) {
+ Core& core = *(m_scene.m_core);
+
+ auto vertexBuffer = core.createBuffer<uint8_t>(
+ BufferType::VERTEX, vertexGroup.vertexBuffer.data.size()
+ );
+
+ vertexBuffer.fill(vertexGroup.vertexBuffer.data);
+ m_vertices = vertexBuffer.getHandle();
+
+ auto attributes = vertexGroup.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);
+ });
+
+ for (const auto& attribute : attributes) {
+ m_vertexBindings.emplace_back(attribute.offset, vertexBuffer.getVulkanHandle());
+ }
+
+ auto indexBuffer = core.createBuffer<uint8_t>(
+ BufferType::INDEX, vertexGroup.indexBuffer.data.size()
+ );
+
+ indexBuffer.fill(vertexGroup.indexBuffer.data);
+ m_indices = indexBuffer.getHandle();
+ m_indexCount = vertexGroup.numIndices;
+
+ m_bounds.setMin(glm::vec3(
+ vertexGroup.min.x,
+ vertexGroup.min.y,
+ vertexGroup.min.z
+ ));
+
+ m_bounds.setMax(glm::vec3(
+ vertexGroup.max.x,
+ vertexGroup.max.y,
+ vertexGroup.max.z
+ ));
+
+ if ((vertexGroup.materialIndex >= 0) &&
+ (vertexGroup.materialIndex < scene.materials.size())) {
+ m_materialIndex = vertexGroup.materialIndex;
+
+ if (!getMaterial()) {
+ m_scene.loadMaterial(m_materialIndex, scene, scene.materials[vertexGroup.materialIndex]);
+ }
+
+ m_scene.increaseMaterialUsage(m_materialIndex);
+ } else {
+ m_materialIndex = std::numeric_limits<size_t>::max();
+ }
+
+ if (*this) {
+ const auto& material = getMaterial();
+ const auto& descriptorSet = core.getDescriptorSet(material.getDescriptorSet());
+
+ drawcalls.push_back(DrawcallInfo(
+ vkcv::Mesh(m_vertexBindings, indexBuffer.getVulkanHandle(), m_indexCount),
+ { DescriptorSetUsage(0, descriptorSet.vulkanHandle) }
+ ));
+ }
+ }
+
+ MeshPart::~MeshPart() {
+ m_scene.decreaseMaterialUsage(m_materialIndex);
+ }
+
+ MeshPart::MeshPart(const MeshPart &other) :
+ m_scene(other.m_scene),
+ m_vertices(other.m_vertices),
+ m_vertexBindings(other.m_vertexBindings),
+ m_indices(other.m_indices),
+ m_indexCount(other.m_indexCount),
+ m_bounds(other.m_bounds),
+ m_materialIndex(other.m_materialIndex) {
+ m_scene.increaseMaterialUsage(m_materialIndex);
+ }
+
+ MeshPart::MeshPart(MeshPart &&other) :
+ m_scene(other.m_scene),
+ m_vertices(other.m_vertices),
+ m_vertexBindings(other.m_vertexBindings),
+ m_indices(other.m_indices),
+ m_indexCount(other.m_indexCount),
+ m_bounds(other.m_bounds),
+ m_materialIndex(other.m_materialIndex) {
+ m_scene.increaseMaterialUsage(m_materialIndex);
+ }
+
+ MeshPart &MeshPart::operator=(const MeshPart &other) {
+ if (&other == this) {
+ return *this;
+ }
+
+ m_vertices = other.m_vertices;
+ m_vertexBindings = other.m_vertexBindings;
+ m_indices = other.m_indices;
+ m_indexCount = other.m_indexCount;
+ m_bounds = other.m_bounds;
+ m_materialIndex = other.m_materialIndex;
+
+ return *this;
+ }
+
+ MeshPart &MeshPart::operator=(MeshPart &&other) noexcept {
+ m_vertices = other.m_vertices;
+ m_vertexBindings = other.m_vertexBindings;
+ m_indices = other.m_indices;
+ m_indexCount = other.m_indexCount;
+ m_bounds = other.m_bounds;
+ m_materialIndex = other.m_materialIndex;
+
+ return *this;
+ }
+
+ const material::Material & MeshPart::getMaterial() const {
+ return m_scene.getMaterial(m_materialIndex);
+ }
+
+ MeshPart::operator bool() const {
+ return (
+ (getMaterial()) &&
+ (m_vertices) &&
+ (m_indices)
+ );
+ }
+
+ bool MeshPart::operator!() const {
+ return (
+ (!getMaterial()) ||
+ (!m_vertices) ||
+ (!m_indices)
+ );
+ }
+
+ const Bounds &MeshPart::getBounds() const {
+ return m_bounds;
+ }
+
+}
diff --git a/modules/scene/src/vkcv/scene/Node.cpp b/modules/scene/src/vkcv/scene/Node.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..32230099b2f693362bab69d8172a4dee56c4e304
--- /dev/null
+++ b/modules/scene/src/vkcv/scene/Node.cpp
@@ -0,0 +1,189 @@
+
+#include "vkcv/scene/Node.hpp"
+#include "vkcv/scene/Scene.hpp"
+#include "Frustum.hpp"
+
+#include <algorithm>
+
+namespace vkcv::scene {
+
+ Node::Node(Scene& scene) :
+ m_scene(scene),
+ m_meshes(),
+ m_nodes(),
+ m_bounds() {}
+
+ Node::~Node() {
+ m_nodes.clear();
+ m_meshes.clear();
+ }
+
+ Node &Node::operator=(const Node &other) {
+ if (&other == this) {
+ return *this;
+ }
+
+ m_meshes.resize(other.m_meshes.size(), Mesh(m_scene));
+
+ for (size_t i = 0; i < m_meshes.size(); i++) {
+ m_meshes[i] = other.m_meshes[i];
+ }
+
+ m_nodes.resize(other.m_nodes.size(), Node(m_scene));
+
+ for (size_t i = 0; i < m_nodes.size(); i++) {
+ m_nodes[i] = other.m_nodes[i];
+ }
+
+ m_bounds = other.m_bounds;
+
+ return *this;
+ }
+
+ Node &Node::operator=(Node &&other) noexcept {
+ m_meshes.resize(other.m_meshes.size(), Mesh(m_scene));
+
+ for (size_t i = 0; i < m_meshes.size(); i++) {
+ m_meshes[i] = std::move(other.m_meshes[i]);
+ }
+
+ m_nodes.resize(other.m_nodes.size(), Node(m_scene));
+
+ for (size_t i = 0; i < m_nodes.size(); i++) {
+ m_nodes[i] = std::move(other.m_nodes[i]);
+ }
+
+ m_bounds = other.m_bounds;
+
+ return *this;
+ }
+
+ void Node::addMesh(const Mesh& mesh) {
+ if (m_meshes.empty()) {
+ m_bounds = mesh.getBounds();
+ } else {
+ m_bounds.extend(mesh.getBounds().getMin());
+ m_bounds.extend(mesh.getBounds().getMax());
+ }
+
+ m_meshes.push_back(mesh);
+ }
+
+ void Node::loadMesh(const asset::Scene &asset_scene, const asset::Mesh &asset_mesh) {
+ Mesh mesh (m_scene);
+ mesh.load(asset_scene, asset_mesh);
+ addMesh(mesh);
+ }
+
+ size_t Node::addNode() {
+ const Node node (m_scene);
+ const size_t index = m_nodes.size();
+ m_nodes.push_back(node);
+ return index;
+ }
+
+ Node& Node::getNode(size_t index) {
+ return m_nodes[index];
+ }
+
+ const Node& Node::getNode(size_t index) const {
+ return m_nodes[index];
+ }
+
+ void Node::recordDrawcalls(const glm::mat4& viewProjection,
+ PushConstants& pushConstants,
+ std::vector<DrawcallInfo>& drawcalls,
+ const RecordMeshDrawcallFunction& record) {
+ if (!checkFrustum(viewProjection, m_bounds)) {
+ return;
+ }
+
+ for (auto& mesh : m_meshes) {
+ mesh.recordDrawcalls(viewProjection, pushConstants, drawcalls, record);
+ }
+
+ for (auto& node : m_nodes) {
+ node.recordDrawcalls(viewProjection, pushConstants, drawcalls, record);
+ }
+ }
+
+ void Node::splitMeshesToSubNodes(size_t maxMeshesPerNode) {
+ if (m_meshes.size() <= maxMeshesPerNode) {
+ return;
+ }
+
+ const auto split = m_bounds.getCenter();
+ int axis = 0;
+
+ const auto size = m_bounds.getSize();
+
+ if (size[1] > size[0]) {
+ if (size[2] > size[1]) {
+ axis = 2;
+ } else {
+ axis = 1;
+ }
+ } else
+ if (size[2] > size[0]) {
+ axis = 2;
+ }
+
+ std::vector<size_t> left_meshes;
+ std::vector<size_t> right_meshes;
+
+ for (size_t i = 0; i < m_meshes.size(); i++) {
+ const auto& bounds = m_meshes[i].getBounds();
+
+ if (bounds.getMax()[axis] <= split[axis]) {
+ left_meshes.push_back(i);
+ } else
+ if (bounds.getMin()[axis] >= split[axis]) {
+ right_meshes.push_back(i);
+ }
+ }
+
+ if ((left_meshes.empty()) || (right_meshes.empty())) {
+ return;
+ }
+
+ const size_t left = addNode();
+ const size_t right = addNode();
+
+ for (size_t i : left_meshes) {
+ getNode(left).addMesh(m_meshes[i]);
+ }
+
+ for (size_t i : right_meshes) {
+ getNode(right).addMesh(m_meshes[i]);
+ left_meshes.push_back(i);
+ }
+
+ std::sort(left_meshes.begin(), left_meshes.end(), std::greater());
+
+ for (size_t i : left_meshes) {
+ m_meshes.erase(m_meshes.begin() + static_cast<long>(i));
+ }
+
+ getNode(left).splitMeshesToSubNodes(maxMeshesPerNode);
+ getNode(right).splitMeshesToSubNodes(maxMeshesPerNode);
+ }
+
+ size_t Node::getDrawcallCount() const {
+ size_t count = 0;
+
+ for (auto& mesh : m_meshes) {
+ count += mesh.getDrawcallCount();
+ }
+
+ for (auto& node : m_nodes) {
+ count += node.getDrawcallCount();
+ }
+
+ return count;
+ }
+
+ const Bounds& Node::getBounds() const {
+ return m_bounds;
+ }
+
+}
diff --git a/modules/scene/src/vkcv/scene/Scene.cpp b/modules/scene/src/vkcv/scene/Scene.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d6fa2a40a494ef57386e52a306e962a460c66dd6
--- /dev/null
+++ b/modules/scene/src/vkcv/scene/Scene.cpp
@@ -0,0 +1,273 @@
+
+#include "vkcv/scene/Scene.hpp"
+
+#include <vkcv/Logger.hpp>
+#include <vkcv/asset/asset_loader.hpp>
+
+namespace vkcv::scene {
+
+ Scene::Scene(Core* core) :
+ m_core(core),
+ m_materials(),
+ m_nodes() {}
+
+ Scene::~Scene() {
+ m_nodes.clear();
+ m_materials.clear();
+ }
+
+ Scene::Scene(const Scene &other) :
+ m_core(other.m_core),
+ m_materials(other.m_materials),
+ m_nodes() {
+ m_nodes.resize(other.m_nodes.size(), Node(*this));
+
+ for (size_t i = 0; i < m_nodes.size(); i++) {
+ m_nodes[i] = other.m_nodes[i];
+ }
+ }
+
+ Scene::Scene(Scene &&other) noexcept :
+ m_core(other.m_core),
+ m_materials(other.m_materials),
+ m_nodes() {
+ m_nodes.resize(other.m_nodes.size(), Node(*this));
+
+ for (size_t i = 0; i < m_nodes.size(); i++) {
+ m_nodes[i] = std::move(other.m_nodes[i]);
+ }
+ }
+
+ Scene &Scene::operator=(const Scene &other) {
+ if (&other == this) {
+ return *this;
+ }
+
+ m_core = other.m_core;
+ m_materials = std::vector<Material>(other.m_materials);
+
+ m_nodes.resize(other.m_nodes.size(), Node(*this));
+
+ for (size_t i = 0; i < m_nodes.size(); i++) {
+ m_nodes[i] = other.m_nodes[i];
+ }
+
+ return *this;
+ }
+
+ Scene &Scene::operator=(Scene &&other) noexcept {
+ m_core = other.m_core;
+ m_materials = std::move(other.m_materials);
+
+ m_nodes.resize(other.m_nodes.size(), Node(*this));
+
+ for (size_t i = 0; i < m_nodes.size(); i++) {
+ m_nodes[i] = std::move(other.m_nodes[i]);
+ }
+
+ return *this;
+ }
+
+ size_t Scene::addNode() {
+ const Node node (*this);
+ const size_t index = m_nodes.size();
+ m_nodes.push_back(node);
+ return index;
+ }
+
+ Node& Scene::getNode(size_t index) {
+ return m_nodes[index];
+ }
+
+ const Node& Scene::getNode(size_t index) const {
+ return m_nodes[index];
+ }
+
+ void Scene::increaseMaterialUsage(size_t index) {
+ if (index < m_materials.size()) {
+ m_materials[index].m_usages++;
+ }
+ }
+
+ void Scene::decreaseMaterialUsage(size_t index) {
+ if ((index < m_materials.size()) && (m_materials[index].m_usages > 0)) {
+ m_materials[index].m_usages--;
+ }
+ }
+
+ size_t Scene::getMaterialCount() const {
+ return m_materials.size();
+ }
+
+ const material::Material & Scene::getMaterial(size_t index) const {
+ static material::Material noMaterial;
+
+ if (index >= m_materials.size()) {
+ return noMaterial;
+ }
+
+ return m_materials[index].m_data;
+ }
+
+ void Scene::recordDrawcalls(CommandStreamHandle &cmdStream,
+ const camera::Camera &camera,
+ const PassHandle &pass,
+ const PipelineHandle &pipeline,
+ size_t pushConstantsSizePerDrawcall,
+ const RecordMeshDrawcallFunction &record,
+ const std::vector<ImageHandle> &renderTargets) {
+ PushConstants pushConstants (pushConstantsSizePerDrawcall);
+ std::vector<DrawcallInfo> drawcalls;
+ size_t count = 0;
+
+ const glm::mat4 viewProjection = camera.getMVP();
+
+ for (auto& node : m_nodes) {
+ count += node.getDrawcallCount();
+ node.recordDrawcalls(viewProjection, pushConstants, drawcalls, record);
+ }
+
+ vkcv_log(LogLevel::RAW_INFO, "Frustum culling: %lu / %lu", drawcalls.size(), count);
+
+ m_core->recordDrawcallsToCmdStream(
+ cmdStream,
+ pass,
+ pipeline,
+ pushConstants,
+ drawcalls,
+ renderTargets
+ );
+ }
+
+ Scene Scene::create(Core& core) {
+ return Scene(&core);
+ }
+
+ static void loadImage(Core& core, const asset::Scene& asset_scene,
+ const asset::Texture& asset_texture,
+ const vk::Format& format,
+ ImageHandle& image, SamplerHandle& sampler) {
+ asset::Sampler* asset_sampler = nullptr;
+
+ if ((asset_texture.sampler >= 0) && (asset_texture.sampler < asset_scene.samplers.size())) {
+ //asset_sampler = &(asset_scene.samplers[asset_texture.sampler]); // TODO
+ }
+
+ Image img = core.createImage(format, asset_texture.w, asset_texture.h);
+ img.fill(asset_texture.data.data());
+ image = img.getHandle();
+
+ if (asset_sampler) {
+ //sampler = core.createSampler(asset_sampler) // TODO
+ } else {
+ sampler = core.createSampler(
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerFilterType::LINEAR,
+ vkcv::SamplerMipmapMode::LINEAR,
+ vkcv::SamplerAddressMode::REPEAT
+ );
+ }
+ }
+
+ void Scene::loadMaterial(size_t index, const asset::Scene& scene,
+ const asset::Material& material) {
+ if (index >= m_materials.size()) {
+ return;
+ }
+
+ ImageHandle diffuseImg;
+ SamplerHandle diffuseSmp;
+
+ if ((material.baseColor >= 0) && (material.baseColor < scene.textures.size())) {
+ loadImage(*m_core, scene, scene.textures[material.baseColor], vk::Format::eR8G8B8A8Srgb,
+ diffuseImg,diffuseSmp);
+ }
+
+ ImageHandle normalImg;
+ SamplerHandle normalSmp;
+
+ if ((material.baseColor >= 0) && (material.baseColor < scene.textures.size())) {
+ loadImage(*m_core, scene, scene.textures[material.baseColor], vk::Format::eR8G8B8A8Srgb,
+ diffuseImg,diffuseSmp);
+ }
+
+ ImageHandle metalRoughImg;
+ SamplerHandle metalRoughSmp;
+
+ if ((material.baseColor >= 0) && (material.baseColor < scene.textures.size())) {
+ loadImage(*m_core, scene, scene.textures[material.baseColor], vk::Format::eR8G8B8A8Srgb,
+ diffuseImg,diffuseSmp);
+ }
+
+ ImageHandle occlusionImg;
+ SamplerHandle occlusionSmp;
+
+ if ((material.baseColor >= 0) && (material.baseColor < scene.textures.size())) {
+ loadImage(*m_core, scene, scene.textures[material.baseColor], vk::Format::eR8G8B8A8Srgb,
+ diffuseImg,diffuseSmp);
+ }
+
+ ImageHandle emissionImg;
+ SamplerHandle emissionSmp;
+
+ if ((material.baseColor >= 0) && (material.baseColor < scene.textures.size())) {
+ loadImage(*m_core, scene, scene.textures[material.baseColor], vk::Format::eR8G8B8A8Srgb,
+ diffuseImg,diffuseSmp);
+ }
+
+ const float colorFactors [4] = {
+ material.baseColorFactor.r,
+ material.baseColorFactor.g,
+ material.baseColorFactor.b,
+ material.baseColorFactor.a
+ };
+
+ const float emissionFactors[4] = {
+ material.emissiveFactor.r,
+ material.emissiveFactor.g,
+ material.emissiveFactor.b
+ };
+
+ m_materials[index].m_data = material::Material::createPBR(
+ *m_core,
+ diffuseImg, diffuseSmp,
+ normalImg, normalSmp,
+ metalRoughImg, metalRoughSmp,
+ occlusionImg, occlusionSmp,
+ emissionImg, emissionSmp,
+ colorFactors,
+ material.normalScale,
+ material.metallicFactor,
+ material.roughnessFactor,
+ material.occlusionStrength,
+ emissionFactors
+ );
+ }
+
+ Scene Scene::load(Core& core, const std::filesystem::path &path) {
+ asset::Scene asset_scene;
+
+ if (!asset::loadScene(path.string(), asset_scene)) {
+ vkcv_log(LogLevel::ERROR, "Scene could not be loaded (%s)", path.c_str());
+ return create(core);
+ }
+
+ Scene scene = create(core);
+
+ for (const auto& material : asset_scene.materials) {
+ scene.m_materials.push_back({
+ 0, material::Material()
+ });
+ }
+
+ const size_t root = scene.addNode();
+
+ for (const auto& mesh : asset_scene.meshes) {
+ scene.getNode(root).loadMesh(asset_scene, mesh);
+ }
+
+ scene.getNode(root).splitMeshesToSubNodes(128);
+ return scene;
+ }
+
+}
diff --git a/projects/CMakeLists.txt b/projects/CMakeLists.txt
index 99a3cb382ec02bab64e9fc714ceeb7e5cef39ed0..4196d55d99db115641f0a23cf5d7445bc70e52fe 100644
--- a/projects/CMakeLists.txt
+++ b/projects/CMakeLists.txt
@@ -3,4 +3,5 @@
add_subdirectory(first_triangle)
add_subdirectory(first_mesh)
add_subdirectory(first_scene)
-add_subdirectory(voxelization)
\ No newline at end of file
+add_subdirectory(particle_simulation)
+add_subdirectory(voxelization)
diff --git a/projects/cmd_sync_test/src/main.cpp b/projects/cmd_sync_test/src/main.cpp
deleted file mode 100644
index 7ec54582aac6b16a484b74183036539e91cfe731..0000000000000000000000000000000000000000
--- a/projects/cmd_sync_test/src/main.cpp
+++ /dev/null
@@ -1,317 +0,0 @@
-#include <iostream>
-#include <vkcv/Core.hpp>
-#include <GLFW/glfw3.h>
-#include <vkcv/camera/CameraManager.hpp>
-#include <chrono>
-#include <vkcv/asset/asset_loader.hpp>
-
-int main(int argc, const char** argv) {
- const char* applicationName = "First Mesh";
-
- uint32_t windowWidth = 800;
- uint32_t windowHeight = 600;
-
- vkcv::Window window = vkcv::Window::create(
- applicationName,
- windowWidth,
- windowHeight,
- 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);
- cameraManager.getCamera(camIndex).setYaw(180.0f);
-
- cameraManager.getCamera(camIndex2).setNearFar(0.1f, 30.0f);
-
- window.initEvents();
-
- 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" }
- );
-
- vkcv::asset::Scene mesh;
-
- const char* path = argc > 1 ? argv[1] : "resources/cube/cube.gltf";
- int result = vkcv::asset::loadScene(path, mesh);
-
- if (result == 1) {
- std::cout << "Mesh loading successful!" << std::endl;
- }
- else {
- std::cout << "Mesh loading failed: " << result << std::endl;
- return 1;
- }
-
- assert(mesh.vertexGroups.size() > 0);
- auto vertexBuffer = core.createBuffer<uint8_t>(
- vkcv::BufferType::VERTEX,
- mesh.vertexGroups[0].vertexBuffer.data.size(),
- vkcv::BufferMemoryType::DEVICE_LOCAL
- );
-
- vertexBuffer.fill(mesh.vertexGroups[0].vertexBuffer.data);
-
- auto indexBuffer = core.createBuffer<uint8_t>(
- vkcv::BufferType::INDEX,
- mesh.vertexGroups[0].indexBuffer.data.size(),
- vkcv::BufferMemoryType::DEVICE_LOCAL
- );
-
- indexBuffer.fill(mesh.vertexGroups[0].indexBuffer.data);
-
- 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);
- });
-
- const std::vector<vkcv::VertexBufferBinding> vertexBufferBindings = {
- vkcv::VertexBufferBinding(attributes[0].offset, vertexBuffer.getVulkanHandle()),
- vkcv::VertexBufferBinding(attributes[1].offset, vertexBuffer.getVulkanHandle()),
- vkcv::VertexBufferBinding(attributes[2].offset, vertexBuffer.getVulkanHandle()) };
-
- const vkcv::Mesh loadedMesh(vertexBufferBindings, indexBuffer.getVulkanHandle(), mesh.vertexGroups[0].numIndices);
-
- // an example attachment for passes that output to the window
- const vkcv::AttachmentDescription present_color_attachment(
- vkcv::AttachmentOperation::STORE,
- vkcv::AttachmentOperation::CLEAR,
- core.getSwapchain().getFormat()
- );
-
- const vkcv::AttachmentDescription depth_attachment(
- vkcv::AttachmentOperation::STORE,
- vkcv::AttachmentOperation::CLEAR,
- vk::Format::eD32Sfloat
- );
-
- vkcv::PassConfig firstMeshPassDefinition({ present_color_attachment, depth_attachment });
- vkcv::PassHandle firstMeshPass = core.createPass(firstMeshPassDefinition);
-
- if (!firstMeshPass) {
- std::cout << "Error. Could not create renderpass. Exiting." << std::endl;
- return EXIT_FAILURE;
- }
-
- vkcv::ShaderProgram firstMeshProgram{};
- firstMeshProgram.addShader(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/vert.spv"));
- firstMeshProgram.addShader(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/frag.spv"));
-
- const std::vector<vkcv::VertexAttachment> vertexAttachments = firstMeshProgram.getVertexAttachments();
-
- 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 firstMeshLayout (bindings);
-
- std::vector<vkcv::DescriptorBinding> descriptorBindings = { firstMeshProgram.getReflectedDescriptors()[0] };
- vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(descriptorBindings);
-
- const vkcv::PipelineConfig firstMeshPipelineConfig {
- firstMeshProgram,
- windowWidth,
- windowHeight,
- firstMeshPass,
- firstMeshLayout,
- { core.getDescriptorSet(descriptorSet).layout },
- true
- };
-
- vkcv::PipelineHandle firstMeshPipeline = core.createGraphicsPipeline(firstMeshPipelineConfig);
-
- if (!firstMeshPipeline) {
- std::cout << "Error. Could not create graphics pipeline. Exiting." << std::endl;
- return EXIT_FAILURE;
- }
-
- //vkcv::Image texture = core.createImage(vk::Format::eR8G8B8A8Srgb, mesh.texture_hack.w, mesh.texture_hack.h);
- //texture.fill(mesh.texture_hack.img);
- vkcv::asset::Texture &tex = mesh.textures[0];
- vkcv::Image texture = core.createImage(vk::Format::eR8G8B8A8Srgb, tex.w, tex.h);
- texture.fill(tex.data.data());
-
- vkcv::SamplerHandle sampler = core.createSampler(
- vkcv::SamplerFilterType::LINEAR,
- vkcv::SamplerFilterType::LINEAR,
- vkcv::SamplerMipmapMode::LINEAR,
- vkcv::SamplerAddressMode::REPEAT
- );
-
- vkcv::SamplerHandle shadowSampler = core.createSampler(
- vkcv::SamplerFilterType::NEAREST,
- vkcv::SamplerFilterType::NEAREST,
- vkcv::SamplerMipmapMode::NEAREST,
- vkcv::SamplerAddressMode::CLAMP_TO_EDGE
- );
-
- vkcv::ImageHandle depthBuffer = core.createImage(vk::Format::eD32Sfloat, windowWidth, windowHeight).getHandle();
-
- const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
-
- const vkcv::DescriptorSetUsage descriptorUsage(0, core.getDescriptorSet(descriptorSet).vulkanHandle);
-
- const std::vector<glm::vec3> instancePositions = {
- glm::vec3( 0.f, -2.f, 0.f),
- glm::vec3( 3.f, 0.f, 0.f),
- glm::vec3(-3.f, 0.f, 0.f),
- glm::vec3( 0.f, 2.f, 0.f),
- glm::vec3( 0.f, -5.f, 0.f)
- };
-
- std::vector<glm::mat4> modelMatrices;
- std::vector<vkcv::DrawcallInfo> drawcalls;
- 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, {}));
- }
-
- modelMatrices.back() *= glm::scale(glm::mat4(1.f), glm::vec3(10.f, 1.f, 10.f));
-
- std::vector<std::array<glm::mat4, 2>> mainPassMatrices;
- std::vector<glm::mat4> mvpLight;
-
- vkcv::ShaderProgram shadowShader;
- shadowShader.addShader(vkcv::ShaderStage::VERTEX, "resources/shaders/shadow_vert.spv");
- shadowShader.addShader(vkcv::ShaderStage::FRAGMENT, "resources/shaders/shadow_frag.spv");
-
- const vk::Format shadowMapFormat = vk::Format::eD16Unorm;
- 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 uint32_t shadowMapResolution = 1024;
- const vkcv::Image shadowMap = core.createImage(shadowMapFormat, shadowMapResolution, shadowMapResolution, 1);
- const vkcv::PipelineConfig shadowPipeConfig {
- shadowShader,
- shadowMapResolution,
- shadowMapResolution,
- shadowPass,
- firstMeshLayout,
- {},
- false
- };
-
- const vkcv::PipelineHandle shadowPipe = core.createGraphicsPipeline(shadowPipeConfig);
-
- struct LightInfo {
- glm::vec3 direction;
- float padding;
- glm::mat4 lightMatrix;
- };
- LightInfo lightInfo;
- vkcv::Buffer lightBuffer = core.createBuffer<LightInfo>(vkcv::BufferType::UNIFORM, sizeof(glm::vec3));
-
- vkcv::DescriptorWrites setWrites;
- setWrites.sampledImageWrites = {
- vkcv::SampledImageDescriptorWrite(0, texture.getHandle()),
- vkcv::SampledImageDescriptorWrite(3, shadowMap.getHandle()) };
- setWrites.samplerWrites = {
- vkcv::SamplerDescriptorWrite(1, sampler),
- vkcv::SamplerDescriptorWrite(4, shadowSampler) };
- setWrites.uniformBufferWrites = { vkcv::UniformBufferDescriptorWrite(2, lightBuffer.getHandle()) };
- core.writeDescriptorSet(descriptorSet, setWrites);
-
- auto start = std::chrono::system_clock::now();
- const auto appStartTime = start;
- while (window.isWindowOpen()) {
- vkcv::Window::pollEvents();
-
- uint32_t swapchainWidth, swapchainHeight;
- if (!core.beginFrame(swapchainWidth, swapchainHeight)) {
- continue;
- }
-
- if ((swapchainWidth != windowWidth) || ((swapchainHeight != windowHeight))) {
- depthBuffer = core.createImage(vk::Format::eD32Sfloat, swapchainWidth, swapchainHeight).getHandle();
-
- windowWidth = swapchainWidth;
- windowHeight = swapchainHeight;
- }
-
- auto end = std::chrono::system_clock::now();
- auto deltatime = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
-
- start = end;
- cameraManager.update(0.000001 * static_cast<double>(deltatime.count()));
-
- auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - appStartTime);
-
- const float sunTheta = 0.001f * static_cast<float>(duration.count());
- lightInfo.direction = glm::normalize(glm::vec3(std::cos(sunTheta), 1, std::sin(sunTheta)));
-
- const float shadowProjectionSize = 5.f;
- glm::mat4 projectionLight = glm::ortho(
- -shadowProjectionSize,
- shadowProjectionSize,
- -shadowProjectionSize,
- shadowProjectionSize,
- -shadowProjectionSize,
- shadowProjectionSize);
-
- glm::mat4 vulkanCorrectionMatrix(1.f);
- vulkanCorrectionMatrix[2][2] = 0.5;
- vulkanCorrectionMatrix[3][2] = 0.5;
- projectionLight = vulkanCorrectionMatrix * projectionLight;
-
- const glm::mat4 viewLight = glm::lookAt(glm::vec3(0), -lightInfo.direction, glm::vec3(0, -1, 0));
-
- lightInfo.lightMatrix = projectionLight * viewLight;
- lightBuffer.fill({ lightInfo });
-
- const glm::mat4 viewProjectionCamera = cameraManager.getActiveCamera().getMVP();
-
- mainPassMatrices.clear();
- mvpLight.clear();
- for (const auto& m : modelMatrices) {
- mainPassMatrices.push_back({ viewProjectionCamera * m, m });
- mvpLight.push_back(lightInfo.lightMatrix* m);
- }
-
- vkcv::PushConstantData pushConstantData((void*)mainPassMatrices.data(), 2 * sizeof(glm::mat4));
- const std::vector<vkcv::ImageHandle> renderTargets = { swapchainInput, depthBuffer };
-
- vkcv::PushConstantData shadowPushConstantData((void*)mvpLight.data(), sizeof(glm::mat4));
-
- auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
-
- core.recordDrawcallsToCmdStream(
- cmdStream,
- shadowPass,
- shadowPipe,
- shadowPushConstantData,
- shadowDrawcalls,
- { shadowMap.getHandle() });
-
- core.prepareImageForSampling(cmdStream, shadowMap.getHandle());
-
- core.recordDrawcallsToCmdStream(
- cmdStream,
- firstMeshPass,
- firstMeshPipeline,
- pushConstantData,
- drawcalls,
- renderTargets);
- core.prepareSwapchainImageForPresent(cmdStream);
- core.submitCommandStream(cmdStream);
-
- core.endFrame();
- }
-
- return 0;
-}
diff --git a/projects/first_mesh/CMakeLists.txt b/projects/first_mesh/CMakeLists.txt
index eb0f028db38707272f9fbcf61662633f2868eedc..6455e75d88eee276fb89b9f7a1b3462fcbc54da2 100644
--- a/projects/first_mesh/CMakeLists.txt
+++ b/projects/first_mesh/CMakeLists.txt
@@ -22,7 +22,7 @@ if(MSVC)
endif()
# including headers of dependencies and the VkCV framework
-target_include_directories(first_mesh SYSTEM BEFORE PRIVATE ${vkcv_include} ${vkcv_includes} ${vkcv_asset_loader_include} ${vkcv_camera_include})
+target_include_directories(first_mesh SYSTEM BEFORE PRIVATE ${vkcv_include} ${vkcv_includes} ${vkcv_asset_loader_include} ${vkcv_camera_include} ${vkcv_shader_compiler_include})
# linking with libraries from all dependencies and the VkCV framework
-target_link_libraries(first_mesh vkcv ${vkcv_libraries} vkcv_asset_loader ${vkcv_asset_loader_libraries} vkcv_camera)
+target_link_libraries(first_mesh vkcv ${vkcv_libraries} vkcv_asset_loader ${vkcv_asset_loader_libraries} vkcv_camera vkcv_shader_compiler)
diff --git a/projects/first_mesh/resources/shaders/compile.bat b/projects/first_mesh/resources/shaders/compile.bat
deleted file mode 100644
index b4521235c40fe5fb163bab874560c2f219b7517f..0000000000000000000000000000000000000000
--- a/projects/first_mesh/resources/shaders/compile.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-%VULKAN_SDK%\Bin32\glslc.exe shader.vert -o vert.spv
-%VULKAN_SDK%\Bin32\glslc.exe shader.frag -o frag.spv
-pause
\ No newline at end of file
diff --git a/projects/first_mesh/resources/shaders/frag.spv b/projects/first_mesh/resources/shaders/frag.spv
deleted file mode 100644
index 087e4e22fb2fcec27d99b3ff2aa1a705fe755796..0000000000000000000000000000000000000000
Binary files a/projects/first_mesh/resources/shaders/frag.spv and /dev/null differ
diff --git a/projects/first_mesh/resources/shaders/vert.spv b/projects/first_mesh/resources/shaders/vert.spv
deleted file mode 100644
index 374c023e14b351eb43cbcda5951cbb8b3d6f96a1..0000000000000000000000000000000000000000
Binary files a/projects/first_mesh/resources/shaders/vert.spv and /dev/null differ
diff --git a/projects/first_mesh/src/main.cpp b/projects/first_mesh/src/main.cpp
index 74e6de3ff6d9f80d764b774fea5dc55b4b53b2f8..731d3e56975ff0cd2d8e6d503a19d56de1b922fe 100644
--- a/projects/first_mesh/src/main.cpp
+++ b/projects/first_mesh/src/main.cpp
@@ -4,6 +4,7 @@
#include <vkcv/camera/CameraManager.hpp>
#include <chrono>
#include <vkcv/asset/asset_loader.hpp>
+#include <vkcv/shader/GLSLCompiler.hpp>
int main(int argc, const char** argv) {
const char* applicationName = "First Mesh";
@@ -18,8 +19,6 @@ int main(int argc, const char** argv) {
true
);
- window.initEvents();
-
vkcv::Core core = vkcv::Core::create(
window,
applicationName,
@@ -36,9 +35,8 @@ int main(int argc, const char** argv) {
if (result == 1) {
std::cout << "Mesh loading successful!" << std::endl;
- }
- else {
- std::cout << "Mesh loading failed: " << result << std::endl;
+ } else {
+ std::cerr << "Mesh loading failed: " << result << std::endl;
return 1;
}
@@ -76,15 +74,25 @@ int main(int argc, const char** argv) {
vkcv::PassHandle firstMeshPass = core.createPass(firstMeshPassDefinition);
if (!firstMeshPass) {
- std::cout << "Error. Could not create renderpass. Exiting." << std::endl;
+ std::cerr << "Error. Could not create renderpass. Exiting." << std::endl;
return EXIT_FAILURE;
}
- vkcv::ShaderProgram firstMeshProgram{};
- firstMeshProgram.addShader(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/vert.spv"));
- firstMeshProgram.addShader(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/frag.spv"));
+ vkcv::ShaderProgram firstMeshProgram;
+ vkcv::shader::GLSLCompiler compiler;
+ compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/shader.vert"),
+ [&firstMeshProgram](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ firstMeshProgram.addShader(shaderStage, path);
+ });
+
+ compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/shader.frag"),
+ [&firstMeshProgram](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ firstMeshProgram.addShader(shaderStage, path);
+ });
+
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);
@@ -114,12 +122,15 @@ int main(int argc, const char** argv) {
vkcv::PipelineHandle firstMeshPipeline = core.createGraphicsPipeline(firstMeshPipelineConfig);
if (!firstMeshPipeline) {
- std::cout << "Error. Could not create graphics pipeline. Exiting." << std::endl;
+ std::cerr << "Error. Could not create graphics pipeline. Exiting." << std::endl;
+ return EXIT_FAILURE;
+ }
+
+ if (mesh.textures.empty()) {
+ std::cerr << "Error. No textures found. Exiting." << std::endl;
return EXIT_FAILURE;
}
- // FIXME There should be a test here to make sure there is at least 1
- // texture in the mesh.
vkcv::asset::Texture &tex = mesh.textures[0];
vkcv::Image texture = core.createImage(vk::Format::eR8G8B8A8Srgb, tex.w, tex.h);
texture.fill(tex.data.data());
@@ -151,7 +162,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);
@@ -186,7 +197,8 @@ int main(int argc, const char** argv) {
cameraManager.update(0.000001 * static_cast<double>(deltatime.count()));
glm::mat4 mvp = cameraManager.getActiveCamera().getMVP();
- vkcv::PushConstantData pushConstantData((void*)&mvp, sizeof(glm::mat4));
+ vkcv::PushConstants pushConstants (sizeof(glm::mat4));
+ pushConstants.appendDrawcall(mvp);
const std::vector<vkcv::ImageHandle> renderTargets = { swapchainInput, depthBuffer };
auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
@@ -195,7 +207,7 @@ int main(int argc, const char** argv) {
cmdStream,
firstMeshPass,
firstMeshPipeline,
- pushConstantData,
+ pushConstants,
{ drawcall },
renderTargets);
core.prepareSwapchainImageForPresent(cmdStream);
diff --git a/projects/first_scene/CMakeLists.txt b/projects/first_scene/CMakeLists.txt
index 8b90739750011a36b4c1d9e0bff7cba986074228..ba2f7b1a7ae4845a12b9701269361a0a3f8affb7 100644
--- a/projects/first_scene/CMakeLists.txt
+++ b/projects/first_scene/CMakeLists.txt
@@ -22,7 +22,7 @@ if(MSVC)
endif()
# including headers of dependencies and the VkCV framework
-target_include_directories(first_scene SYSTEM BEFORE PRIVATE ${vkcv_include} ${vkcv_includes} ${vkcv_asset_loader_include} ${vkcv_camera_include})
+target_include_directories(first_scene SYSTEM BEFORE PRIVATE ${vkcv_include} ${vkcv_includes} ${vkcv_asset_loader_include} ${vkcv_camera_include} ${vkcv_scene_include} ${vkcv_shader_compiler_include})
# linking with libraries from all dependencies and the VkCV framework
-target_link_libraries(first_scene vkcv ${vkcv_libraries} vkcv_asset_loader ${vkcv_asset_loader_libraries} vkcv_camera)
+target_link_libraries(first_scene vkcv ${vkcv_libraries} vkcv_asset_loader ${vkcv_asset_loader_libraries} vkcv_camera vkcv_scene vkcv_shader_compiler)
diff --git a/projects/first_scene/resources/Sponza/SponzaFloor.bin b/projects/first_scene/resources/Sponza/SponzaFloor.bin
new file mode 100644
index 0000000000000000000000000000000000000000..684251288f35070d2e7d244877fd844cc00ca632
--- /dev/null
+++ b/projects/first_scene/resources/Sponza/SponzaFloor.bin
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:678455aca641cb1f449aa1a5054a7cae132be81c2b333aac283053967da66df0
+size 512
diff --git a/projects/first_scene/resources/Sponza/SponzaFloor.gltf b/projects/first_scene/resources/Sponza/SponzaFloor.gltf
new file mode 100644
index 0000000000000000000000000000000000000000..b45f1c55ef85f2aa1d4bff01df3d9625aa38c809
--- /dev/null
+++ b/projects/first_scene/resources/Sponza/SponzaFloor.gltf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6deb75441b1138b50a6b0eec05e60df276fe8fb6d58118fdfce2090b6fbe734
+size 3139
diff --git a/projects/first_scene/resources/shaders/compile.bat b/projects/first_scene/resources/shaders/compile.bat
deleted file mode 100644
index b4521235c40fe5fb163bab874560c2f219b7517f..0000000000000000000000000000000000000000
--- a/projects/first_scene/resources/shaders/compile.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-%VULKAN_SDK%\Bin32\glslc.exe shader.vert -o vert.spv
-%VULKAN_SDK%\Bin32\glslc.exe shader.frag -o frag.spv
-pause
\ No newline at end of file
diff --git a/projects/first_scene/resources/shaders/frag.spv b/projects/first_scene/resources/shaders/frag.spv
deleted file mode 100644
index 087e4e22fb2fcec27d99b3ff2aa1a705fe755796..0000000000000000000000000000000000000000
Binary files a/projects/first_scene/resources/shaders/frag.spv and /dev/null differ
diff --git a/projects/first_scene/resources/shaders/vert.spv b/projects/first_scene/resources/shaders/vert.spv
deleted file mode 100644
index 374c023e14b351eb43cbcda5951cbb8b3d6f96a1..0000000000000000000000000000000000000000
Binary files a/projects/first_scene/resources/shaders/vert.spv and /dev/null differ
diff --git a/projects/first_scene/src/main.cpp b/projects/first_scene/src/main.cpp
index 9927c3fd62ec951afd3e97122647d65f964c25fa..527eba8c3a1e020e14d92f5d305e2ddced936333 100644
--- a/projects/first_scene/src/main.cpp
+++ b/projects/first_scene/src/main.cpp
@@ -4,17 +4,8 @@
#include <vkcv/camera/CameraManager.hpp>
#include <chrono>
#include <vkcv/asset/asset_loader.hpp>
-#include <vkcv/Logger.hpp>
-
-glm::mat4 arrayTo4x4Matrix(std::array<float,16> array){
- glm::mat4 matrix;
- for (int i = 0; i < 4; i++){
- for (int j = 0; j < 4; j++){
- matrix[i][j] = array[j * 4 + i];
- }
- }
- return matrix;
-}
+#include <vkcv/shader/GLSLCompiler.hpp>
+#include <vkcv/scene/Scene.hpp>
int main(int argc, const char** argv) {
const char* applicationName = "First Scene";
@@ -32,14 +23,12 @@ int main(int argc, const char** argv) {
vkcv::camera::CameraManager cameraManager(window);
uint32_t camIndex0 = cameraManager.addCamera(vkcv::camera::ControllerType::PILOT);
uint32_t camIndex1 = cameraManager.addCamera(vkcv::camera::ControllerType::TRACKBALL);
-
- cameraManager.getCamera(camIndex0).setPosition(glm::vec3(0, 0, -3));
+
+ cameraManager.getCamera(camIndex0).setPosition(glm::vec3(-8, 1, -0.5));
cameraManager.getCamera(camIndex0).setNearFar(0.1f, 30.0f);
cameraManager.getCamera(camIndex1).setNearFar(0.1f, 30.0f);
- window.initEvents();
-
vkcv::Core core = vkcv::Core::create(
window,
applicationName,
@@ -48,66 +37,10 @@ int main(int argc, const char** argv) {
{},
{ "VK_KHR_swapchain" }
);
-
- vkcv::asset::Scene scene;
-
- const char* path = argc > 1 ? argv[1] : "resources/Sponza/Sponza.gltf";
- int result = vkcv::asset::loadScene(path, scene);
-
- if (result == 1) {
- std::cout << "Mesh loading successful!" << std::endl;
- }
- else {
- std::cout << "Mesh loading failed: " << result << std::endl;
- return EXIT_FAILURE;
- }
-
- assert(!scene.vertexGroups.empty());
- std::vector<std::vector<uint8_t>> vBuffers;
- std::vector<std::vector<uint8_t>> iBuffers;
-
- std::vector<vkcv::VertexBufferBinding> vBufferBindings;
- std::vector<std::vector<vkcv::VertexBufferBinding>> vertexBufferBindings;
- std::vector<vkcv::asset::VertexAttribute> vAttributes;
-
- for (int i = 0; i < scene.vertexGroups.size(); i++) {
-
- vBuffers.push_back(scene.vertexGroups[i].vertexBuffer.data);
- iBuffers.push_back(scene.vertexGroups[i].indexBuffer.data);
-
- auto& attributes = scene.vertexGroups[i].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);
- });
- }
-
- std::vector<vkcv::Buffer<uint8_t>> vertexBuffers;
- for (const vkcv::asset::VertexGroup& group : scene.vertexGroups) {
- vertexBuffers.push_back(core.createBuffer<uint8_t>(
- vkcv::BufferType::VERTEX,
- group.vertexBuffer.data.size()));
- vertexBuffers.back().fill(group.vertexBuffer.data);
- }
-
- std::vector<vkcv::Buffer<uint8_t>> indexBuffers;
- for (const auto& dataBuffer : iBuffers) {
- indexBuffers.push_back(core.createBuffer<uint8_t>(
- vkcv::BufferType::INDEX,
- dataBuffer.size()));
- indexBuffers.back().fill(dataBuffer);
- }
-
- int vertexBufferIndex = 0;
- for (const auto& vertexGroup : scene.vertexGroups) {
- for (const auto& attribute : vertexGroup.vertexBuffer.attributes) {
- vAttributes.push_back(attribute);
- vBufferBindings.push_back(vkcv::VertexBufferBinding(attribute.offset, vertexBuffers[vertexBufferIndex].getVulkanHandle()));
- }
- vertexBufferBindings.push_back(vBufferBindings);
- vBufferBindings.clear();
- vertexBufferIndex++;
- }
+
+ vkcv::scene::Scene scene = vkcv::scene::Scene::load(core, std::filesystem::path(
+ argc > 1 ? argv[1] : "resources/Sponza/Sponza.gltf"
+ ));
const vkcv::AttachmentDescription present_color_attachment(
vkcv::AttachmentOperation::STORE,
@@ -129,9 +62,18 @@ int main(int argc, const char** argv) {
return EXIT_FAILURE;
}
- vkcv::ShaderProgram sceneShaderProgram{};
- sceneShaderProgram.addShader(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/vert.spv"));
- sceneShaderProgram.addShader(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/frag.spv"));
+ vkcv::ShaderProgram sceneShaderProgram;
+ vkcv::shader::GLSLCompiler compiler;
+
+ compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/shader.vert"),
+ [&sceneShaderProgram](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ sceneShaderProgram.addShader(shaderStage, path);
+ });
+
+ compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/shader.frag"),
+ [&sceneShaderProgram](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+ sceneShaderProgram.addShader(shaderStage, path);
+ });
const std::vector<vkcv::VertexAttachment> vertexAttachments = sceneShaderProgram.getVertexAttachments();
std::vector<vkcv::VertexBinding> bindings;
@@ -140,41 +82,8 @@ int main(int argc, const char** argv) {
}
const vkcv::VertexLayout sceneLayout(bindings);
-
- uint32_t setID = 0;
-
- std::vector<vkcv::DescriptorBinding> descriptorBindings = { sceneShaderProgram.getReflectedDescriptors()[setID] };
-
- vkcv::SamplerHandle sampler = core.createSampler(
- vkcv::SamplerFilterType::LINEAR,
- vkcv::SamplerFilterType::LINEAR,
- vkcv::SamplerMipmapMode::LINEAR,
- vkcv::SamplerAddressMode::REPEAT
- );
-
- std::vector<vkcv::Image> sceneImages;
- std::vector<vkcv::DescriptorSetHandle> descriptorSets;
- for (const auto& vertexGroup : scene.vertexGroups) {
- descriptorSets.push_back(core.createDescriptorSet(descriptorBindings));
-
- const auto& material = scene.materials[vertexGroup.materialIndex];
-
- int baseColorIndex = material.baseColor;
- if (baseColorIndex < 0) {
- vkcv_log(vkcv::LogLevel::WARNING, "Material lacks base color");
- baseColorIndex = 0;
- }
-
- vkcv::asset::Texture& sceneTexture = scene.textures[baseColorIndex];
-
- sceneImages.push_back(core.createImage(vk::Format::eR8G8B8A8Srgb, sceneTexture.w, sceneTexture.h));
- sceneImages.back().fill(sceneTexture.data.data());
-
- vkcv::DescriptorWrites setWrites;
- setWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(0, sceneImages.back().getHandle()) };
- setWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(1, sampler) };
- core.writeDescriptorSet(descriptorSets.back(), setWrites);
- }
+
+ const auto& material0 = scene.getMaterial(0);
const vkcv::PipelineConfig scenePipelineDefsinition{
sceneShaderProgram,
@@ -182,7 +91,7 @@ int main(int argc, const char** argv) {
UINT32_MAX,
scenePass,
{sceneLayout},
- { core.getDescriptorSet(descriptorSets[0]).layout },
+ { core.getDescriptorSet(material0.getDescriptorSet()).layout },
true };
vkcv::PipelineHandle scenePipeline = core.createGraphicsPipeline(scenePipelineDefsinition);
@@ -194,26 +103,7 @@ int main(int argc, const char** argv) {
vkcv::ImageHandle depthBuffer = core.createImage(vk::Format::eD32Sfloat, windowWidth, windowHeight).getHandle();
const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
-
- std::vector<vkcv::DrawcallInfo> drawcalls;
- for(int i = 0; i < scene.vertexGroups.size(); i++){
- vkcv::Mesh renderMesh(vertexBufferBindings[i], indexBuffers[i].getVulkanHandle(), scene.vertexGroups[i].numIndices);
-
- vkcv::DescriptorSetUsage descriptorUsage(0, core.getDescriptorSet(descriptorSets[i]).vulkanHandle);
-
- drawcalls.push_back(vkcv::DrawcallInfo(renderMesh, {descriptorUsage}));
- }
-
- std::vector<glm::mat4> modelMatrices;
- modelMatrices.resize(scene.vertexGroups.size(), glm::mat4(1.f));
- for (const auto &mesh : scene.meshes) {
- const glm::mat4 m = arrayTo4x4Matrix(mesh.modelMatrix);
- for (const auto &vertexGroupIndex : mesh.vertexGroups) {
- modelMatrices[vertexGroupIndex] = m;
- }
- }
- std::vector<glm::mat4> mvp;
-
+
auto start = std::chrono::system_clock::now();
while (window.isWindowOpen()) {
vkcv::Window::pollEvents();
@@ -238,25 +128,24 @@ int main(int argc, const char** argv) {
start = end;
cameraManager.update(0.000001 * static_cast<double>(deltatime.count()));
- glm::mat4 vp = cameraManager.getActiveCamera().getMVP();
-
- mvp.clear();
- for (const auto& m : modelMatrices) {
- mvp.push_back(vp * m);
- }
-
- vkcv::PushConstantData pushConstantData((void*)mvp.data(), sizeof(glm::mat4));
const std::vector<vkcv::ImageHandle> renderTargets = { swapchainInput, depthBuffer };
auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
- core.recordDrawcallsToCmdStream(
- cmdStream,
- scenePass,
- scenePipeline,
- pushConstantData,
- drawcalls,
- renderTargets);
+ auto recordMesh = [](const glm::mat4& MVP, const glm::mat4& M,
+ vkcv::PushConstants &pushConstants,
+ vkcv::DrawcallInfo& drawcallInfo) {
+ pushConstants.appendDrawcall(MVP);
+ };
+
+ scene.recordDrawcalls(cmdStream,
+ cameraManager.getActiveCamera(),
+ scenePass,
+ scenePipeline,
+ sizeof(glm::mat4),
+ recordMesh,
+ renderTargets);
+
core.prepareSwapchainImageForPresent(cmdStream);
core.submitCommandStream(cmdStream);
core.endFrame();
diff --git a/projects/first_triangle/shaders/comp.spv b/projects/first_triangle/shaders/comp.spv
deleted file mode 100644
index b414e36b2bea66dab00746298e536d029091e0fd..0000000000000000000000000000000000000000
Binary files a/projects/first_triangle/shaders/comp.spv and /dev/null differ
diff --git a/projects/first_triangle/shaders/compile.bat b/projects/first_triangle/shaders/compile.bat
deleted file mode 100644
index 17743a7c49cdfc6e091c43a42a0adb755a731682..0000000000000000000000000000000000000000
--- a/projects/first_triangle/shaders/compile.bat
+++ /dev/null
@@ -1,4 +0,0 @@
-%VULKAN_SDK%\Bin32\glslc.exe shader.vert -o vert.spv
-%VULKAN_SDK%\Bin32\glslc.exe shader.frag -o frag.spv
-%VULKAN_SDK%\Bin32\glslc.exe shader.comp -o comp.spv
-pause
\ No newline at end of file
diff --git a/projects/first_triangle/shaders/frag.spv b/projects/first_triangle/shaders/frag.spv
deleted file mode 100644
index cb13e606fc0041e24ff6a63c0ec7dcca466732aa..0000000000000000000000000000000000000000
Binary files a/projects/first_triangle/shaders/frag.spv and /dev/null differ
diff --git a/projects/first_triangle/shaders/shader.comp b/projects/first_triangle/shaders/shader.comp
deleted file mode 100644
index fad6cd0815f2f09bf92dcc3171e2e3723f5466df..0000000000000000000000000000000000000000
--- a/projects/first_triangle/shaders/shader.comp
+++ /dev/null
@@ -1,25 +0,0 @@
-#version 440
-
-layout(std430, binding = 0) buffer testBuffer
-{
- float test1[10];
- float test2[10];
- float test3[10];
-};
-
-layout( push_constant ) uniform constants{
- float pushConstant;
-};
-
-layout(local_size_x = 5) in;
-
-void main(){
-
- if(gl_GlobalInvocationID.x >= 10){
- return;
- }
-
- test1[gl_GlobalInvocationID.x] = gl_GlobalInvocationID.x;
- test2[gl_GlobalInvocationID.x] = 69; // nice!
- test3[gl_GlobalInvocationID.x] = pushConstant;
-}
\ No newline at end of file
diff --git a/projects/first_triangle/shaders/vert.spv b/projects/first_triangle/shaders/vert.spv
deleted file mode 100644
index 03af5758ffff1b5b6505fe98b02044849026832d..0000000000000000000000000000000000000000
Binary files a/projects/first_triangle/shaders/vert.spv and /dev/null differ
diff --git a/projects/first_triangle/src/main.cpp b/projects/first_triangle/src/main.cpp
index 5a962b8983f6735530b38de5be679096fa997bd5..253efad491e6e320ba5e5e8b270b187e2e79da82 100644
--- a/projects/first_triangle/src/main.cpp
+++ b/projects/first_triangle/src/main.cpp
@@ -2,10 +2,8 @@
#include <vkcv/Core.hpp>
#include <GLFW/glfw3.h>
#include <vkcv/camera/CameraManager.hpp>
-#include <chrono>
-
#include <vkcv/shader/GLSLCompiler.hpp>
-#include <vkcv/gui/GUI.hpp>
+#include <chrono>
int main(int argc, const char** argv) {
const char* applicationName = "First Triangle";
@@ -19,8 +17,6 @@ int main(int argc, const char** argv) {
false
);
- window.initEvents();
-
vkcv::Core core = vkcv::Core::create(
window,
applicationName,
@@ -29,57 +25,13 @@ int main(int argc, const char** argv) {
{},
{ "VK_KHR_swapchain" }
);
-
- vkcv::gui::GUI gui (core, window);
const auto& context = core.getContext();
- const vk::Instance& instance = context.getInstance();
- const vk::PhysicalDevice& physicalDevice = context.getPhysicalDevice();
- const vk::Device& device = context.getDevice();
-
- struct vec3 {
- float x, y, z;
- };
-
- const size_t n = 5027;
-
- auto testBuffer = core.createBuffer<vec3>(vkcv::BufferType::VERTEX, n, vkcv::BufferMemoryType::DEVICE_LOCAL);
- vec3 vec_data[n];
- for (size_t i = 0; i < n; i++) {
- vec_data[i] = { 42, static_cast<float>(i), 7 };
- }
-
- testBuffer.fill(vec_data);
-
- auto triangleIndexBuffer = core.createBuffer<uint16_t>(vkcv::BufferType::INDEX, n, vkcv::BufferMemoryType::DEVICE_LOCAL);
+ auto triangleIndexBuffer = core.createBuffer<uint16_t>(vkcv::BufferType::INDEX, 3, vkcv::BufferMemoryType::DEVICE_LOCAL);
uint16_t indices[3] = { 0, 1, 2 };
triangleIndexBuffer.fill(&indices[0], sizeof(indices));
- /*vec3* m = buffer.map();
- m[0] = { 0, 0, 0 };
- m[1] = { 0, 0, 0 };
- m[2] = { 0, 0, 0 };
- buffer.unmap();*/
-
- vkcv::SamplerHandle sampler = core.createSampler(
- vkcv::SamplerFilterType::NEAREST,
- vkcv::SamplerFilterType::NEAREST,
- vkcv::SamplerMipmapMode::NEAREST,
- vkcv::SamplerAddressMode::REPEAT
- );
-
- std::cout << "Physical device: " << physicalDevice.getProperties().deviceName << std::endl;
-
- switch (physicalDevice.getProperties().vendorID) {
- case 0x1002: std::cout << "Running AMD huh? You like underdogs, are you a Linux user?" << std::endl; break;
- case 0x10DE: std::cout << "An NVidia GPU, how predictable..." << std::endl; break;
- case 0x8086: std::cout << "Poor child, running on an Intel GPU, probably integrated..."
- "or perhaps you are from the future with a dedicated one?" << std::endl; break;
- case 0x13B5: std::cout << "ARM? What the hell are you running on, next thing I know you're trying to run Vulkan on a leg..." << std::endl; break;
- default: std::cout << "Unknown GPU vendor?! Either you're on an exotic system or your driver is broken..." << std::endl;
- }
-
// an example attachment for passes that output to the window
const vkcv::AttachmentDescription present_color_attachment(
vkcv::AttachmentOperation::STORE,
@@ -95,7 +47,7 @@ int main(int argc, const char** argv) {
return EXIT_FAILURE;
}
- vkcv::ShaderProgram triangleShaderProgram{};
+ vkcv::ShaderProgram triangleShaderProgram;
vkcv::shader::GLSLCompiler compiler;
compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("shaders/shader.vert"),
@@ -125,64 +77,26 @@ int main(int argc, const char** argv) {
std::cout << "Error. Could not create graphics pipeline. Exiting." << std::endl;
return EXIT_FAILURE;
}
-
- // Compute Pipeline
- vkcv::ShaderProgram computeShaderProgram{};
- computeShaderProgram.addShader(vkcv::ShaderStage::COMPUTE, std::filesystem::path("shaders/comp.spv"));
-
- // take care, assuming shader has exactly one descriptor set
- vkcv::DescriptorSetHandle computeDescriptorSet = core.createDescriptorSet(computeShaderProgram.getReflectedDescriptors()[0]);
-
- vkcv::PipelineHandle computePipeline = core.createComputePipeline(
- computeShaderProgram,
- { core.getDescriptorSet(computeDescriptorSet).layout });
-
- struct ComputeTestBuffer {
- float test1[10];
- float test2[10];
- float test3[10];
- };
-
- vkcv::Buffer computeTestBuffer = core.createBuffer<ComputeTestBuffer>(vkcv::BufferType::STORAGE, 1);
-
- vkcv::DescriptorWrites computeDescriptorWrites;
- computeDescriptorWrites.storageBufferWrites = { vkcv::StorageBufferDescriptorWrite(0, computeTestBuffer.getHandle()) };
- core.writeDescriptorSet(computeDescriptorSet, computeDescriptorWrites);
-
- /*
- * BufferHandle triangleVertices = core.createBuffer(vertices);
- * BufferHandle triangleIndices = core.createBuffer(indices);
- *
- * // triangle Model creation goes here
- *
- *
- * // attachment creation goes here
- * PassHandle trianglePass = core.CreatePass(presentationPass);
- *
- * // shader creation goes here
- * // material creation goes here
- *
- * PipelineHandle trianglePipeline = core.CreatePipeline(trianglePipeline);
- */
+
auto start = std::chrono::system_clock::now();
- 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();
vkcv::camera::CameraManager cameraManager(window);
- uint32_t camIndex = cameraManager.addCamera(vkcv::camera::ControllerType::PILOT);
- uint32_t camIndex2 = cameraManager.addCamera(vkcv::camera::ControllerType::TRACKBALL);
+ uint32_t camIndex0 = cameraManager.addCamera(vkcv::camera::ControllerType::PILOT);
+ uint32_t camIndex1 = cameraManager.addCamera(vkcv::camera::ControllerType::TRACKBALL);
- cameraManager.getCamera(camIndex).setPosition(glm::vec3(0, 0, -2));
+ cameraManager.getCamera(camIndex0).setPosition(glm::vec3(0, 0, -2));
+ cameraManager.getCamera(camIndex1).setPosition(glm::vec3(0.0f, 0.0f, 0.0f));
+ cameraManager.getCamera(camIndex1).setCenter(glm::vec3(0.0f, 0.0f, -1.0f));
while (window.isWindowOpen())
{
- window.pollEvents();
-
+ vkcv::Window::pollEvents();
+
uint32_t swapchainWidth, swapchainHeight; // No resizing = No problem
if (!core.beginFrame(swapchainWidth, swapchainHeight)) {
continue;
@@ -195,37 +109,21 @@ int main(int argc, const char** argv) {
cameraManager.update(0.000001 * static_cast<double>(deltatime.count()));
glm::mat4 mvp = cameraManager.getActiveCamera().getMVP();
- vkcv::PushConstantData pushConstantData((void*)&mvp, sizeof(glm::mat4));
+ vkcv::PushConstants pushConstants (sizeof(glm::mat4));
+ pushConstants.appendDrawcall(mvp);
+
auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
core.recordDrawcallsToCmdStream(
cmdStream,
trianglePass,
trianglePipeline,
- pushConstantData,
+ pushConstants,
{ drawcall },
{ swapchainInput });
- const uint32_t dispatchSize[3] = { 2, 1, 1 };
- const float theMeaningOfLife = 42;
-
- core.recordComputeDispatchToCmdStream(
- cmdStream,
- computePipeline,
- dispatchSize,
- { vkcv::DescriptorSetUsage(0, core.getDescriptorSet(computeDescriptorSet).vulkanHandle) },
- vkcv::PushConstantData((void*)&theMeaningOfLife, sizeof(theMeaningOfLife)));
-
core.prepareSwapchainImageForPresent(cmdStream);
core.submitCommandStream(cmdStream);
-
- gui.beginGUI();
-
- ImGui::Begin("Hello world");
- ImGui::Text("This is a test!");
- ImGui::End();
-
- gui.endGUI();
core.endFrame();
}
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..98d53c2a1a2c08d40473858b47aacf34da30f7ed
--- /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::PushConstants(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::PushConstants(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::PushConstants(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::PushConstants(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::PushConstants(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..b80d063d382c9ae1cb63887388cce065b8289b63
--- /dev/null
+++ b/projects/particle_simulation/src/Particle.cpp
@@ -0,0 +1,42 @@
+
+#include "Particle.hpp"
+
+Particle::Particle(glm::vec3 position, glm::vec3 velocity, float lifeTime)
+: m_position(position),
+ m_lifeTime(lifeTime),
+ m_velocity(velocity),
+ m_mass(1.0f),
+ m_reset_velocity(velocity)
+{}
+
+const glm::vec3& Particle::getPosition()const{
+ return m_position;
+}
+
+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..73e7cbf517709ee03274cfd199081ade3f756545
--- /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 );
+
+ 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 m_mass;
+ glm::vec3 m_reset_velocity;
+ float padding_3;
+};
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..0d83644b866f5f89fb33c68f1d5a79fcee8c028a
--- /dev/null
+++ b/projects/particle_simulation/src/main.cpp
@@ -0,0 +1,321 @@
+#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 or gravity
+ std::string shaderPathCompute = "shaders/shader_space.comp";
+ std::string shaderPathFragment = "shaders/shader_space.frag";
+
+ for (int i = 1; i < argc; i++) {
+ if (strcmp(argv[i], "--space") == 0) {
+ shaderPathCompute = "shaders/shader_space.comp";
+ shaderPathFragment = "shaders/shader_space.frag";
+ } else
+ if (strcmp(argv[i], "--water") == 0) {
+ shaderPathCompute = "shaders/shader_water.comp";
+ shaderPathFragment = "shaders/shader_water.frag";
+ } else
+ if (strcmp(argv[i], "--gravity") == 0) {
+ shaderPathCompute = "shaders/shader_gravity.comp";
+ shaderPathFragment = "shaders/shader_space.frag";
+ }
+ }
+
+ vkcv::shader::GLSLCompiler compiler;
+ vkcv::ShaderProgram computeShaderProgram{};
+ compiler.compile(vkcv::ShaderStage::COMPUTE, shaderPathCompute, [&](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, shaderPathFragment, [&](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);
+
+ auto pos = glm::vec2(0.f);
+ auto spawnPosition = glm::vec3(0.f);
+
+ window.e_mouseMove.add([&](double offsetX, double offsetY) {
+ pos = glm::vec2(static_cast<float>(offsetX), static_cast<float>(offsetY));
+ 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());
+ spawnPosition = glm::vec3(pos.x, pos.y, 0.f);
+ particleSystem.setRespawnPos(glm::vec3(-spawnPosition.x, spawnPosition.y, spawnPosition.z));
+ });
+
+ 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()) {
+ vkcv::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;
+
+ cameraManager.update(deltatime);
+
+ // split view and projection to allow for easy billboarding in shader
+ struct {
+ glm::mat4 view;
+ glm::mat4 projection;
+ } renderingMatrices;
+
+ renderingMatrices.view = cameraManager.getActiveCamera().getView();
+ renderingMatrices.projection = cameraManager.getActiveCamera().getProjection();
+
+ auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
+ float random = rdm(rdmEngine);
+ glm::vec2 pushData = glm::vec2(deltatime, random);
+
+ vkcv::PushConstants pushConstantsCompute (sizeof(glm::vec2));
+ pushConstantsCompute.appendDrawcall(pushData);
+
+ 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)},
+ pushConstantsCompute);
+
+ core.recordBufferMemoryBarrier(cmdStream, particleBuffer.getHandle());
+
+ vkcv::PushConstants pushConstantsDraw (sizeof(renderingMatrices));
+ pushConstantsDraw.appendDrawcall(renderingMatrices);
+
+ core.recordDrawcallsToCmdStream(
+ cmdStream,
+ particlePass,
+ particlePipeline,
+ pushConstantsDraw,
+ {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::PushConstants(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..6cb02e9035daf7abebc047d26137d0ba973bb4f1
--- /dev/null
+++ b/projects/voxelization/src/BloomAndFlares.cpp
@@ -0,0 +1,344 @@
+#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::PushConstants(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::PushConstants(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::PushConstants(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::PushConstants(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::PushConstants(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
+ };
+
+ vkcv::PushConstants pushConstants (sizeof(cameraForward));
+ pushConstants.appendDrawcall(cameraForward);
+
+ // bloom composite dispatch
+ p_Core->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_CompositePipe,
+ compositeDispatchCount,
+ {vkcv::DescriptorSetUsage(0, p_Core->getDescriptorSet(m_CompositeDescSet).vulkanHandle)},
+ pushConstants);
+}
+
+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..32dd5457541f8f09f4d2711ea831e3c78de2303a
--- /dev/null
+++ b/projects/voxelization/src/ShadowMapping.cpp
@@ -0,0 +1,325 @@
+#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 });
+
+ vkcv::PushConstants shadowPushConstants (sizeof(glm::mat4));
+
+ for (const auto& m : modelMatrices) {
+ shadowPushConstants.appendDrawcall(lightInfo.lightMatrix * m);
+ }
+
+
+ std::vector<vkcv::DrawcallInfo> drawcalls;
+ for (const auto& mesh : meshes) {
+ drawcalls.push_back(vkcv::DrawcallInfo(mesh, {}));
+ }
+
+ m_corePtr->recordDrawcallsToCmdStream(
+ cmdStream,
+ m_shadowMapPass,
+ m_shadowMapPipe,
+ shadowPushConstants,
+ 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);
+
+ vkcv::PushConstants msaaPushConstants (sizeof(msaaSampleCount));
+ msaaPushConstants.appendDrawcall(msaaSampleCount);
+
+ m_corePtr->prepareImageForStorage(cmdStream, m_shadowMap.getHandle());
+ m_corePtr->recordComputeDispatchToCmdStream(
+ cmdStream,
+ m_depthToMomentsPipe,
+ dispatchCount,
+ { vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_depthToMomentsDescriptorSet).vulkanHandle) },
+ msaaPushConstants);
+ 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::PushConstants(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::PushConstants(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..bbf161ddeb0899a1ce61279b4c476fb19cb906d7 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;
+ m_voxelInfoBuffer.fill({ m_voxelInfo });
- // 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({ 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,48 +230,50 @@ 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;
+
+ vkcv::PushConstants voxelizationPushConstants (2 * sizeof(glm::mat4));
+
for (const auto& m : modelMatrices) {
- voxelizationMatrices.push_back({ voxelizationViewProjection * m, m });
+ voxelizationPushConstants.appendDrawcall(std::array<glm::mat4, 2>{ voxelizationViewProjection * m, m });
}
- const vkcv::PushConstantData voxelizationPushConstantData((void*)voxelizationMatrices.data(), 2 * sizeof(glm::mat4));
-
// reset voxels
const uint32_t resetVoxelGroupSize = 64;
uint32_t resetVoxelDispatchCount[3];
resetVoxelDispatchCount[0] = glm::ceil(voxelCount / float(resetVoxelGroupSize));
resetVoxelDispatchCount[1] = 1;
resetVoxelDispatchCount[2] = 1;
+
+ vkcv::PushConstants voxelCountPushConstants (sizeof(voxelCount));
+ voxelCountPushConstants.appendDrawcall(voxelCount);
- m_corePtr->prepareImageForStorage(cmdStream, m_voxelImage.getHandle());
m_corePtr->recordComputeDispatchToCmdStream(
cmdStream,
m_voxelResetPipe,
resetVoxelDispatchCount,
{ vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_voxelResetDescriptorSet).vulkanHandle) },
- vkcv::PushConstantData(&voxelCount, sizeof(voxelCount)));
+ voxelCountPushConstants);
m_corePtr->recordBufferMemoryBarrier(cmdStream, m_voxelBuffer.getHandle());
// voxelization
std::vector<vkcv::DrawcallInfo> drawcalls;
- for (int i = 0; i < meshes.size(); i++) {
+ for (size_t i = 0; i < meshes.size(); i++) {
drawcalls.push_back(vkcv::DrawcallInfo(
- meshes[i],
+ meshes[i],
{
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,
m_voxelizationPipe,
- voxelizationPushConstantData,
+ voxelizationPushConstants,
drawcalls,
{ m_dummyRenderTarget.getHandle() });
@@ -263,11 +289,30 @@ void Voxelization::voxelizeMeshes(
m_bufferToImagePipe,
bufferToImageDispatchCount,
{ vkcv::DescriptorSetUsage(0, m_corePtr->getDescriptorSet(m_bufferToImageDescriptorSet).vulkanHandle) },
- vkcv::PushConstantData(nullptr, 0));
+ vkcv::PushConstants(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::PushConstants(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(
@@ -276,7 +321,8 @@ void Voxelization::renderVoxelVisualisation(
const std::vector<vkcv::ImageHandle>& renderTargets,
uint32_t mipLevel) {
- const vkcv::PushConstantData voxelVisualisationPushConstantData((void*)&viewProjectin, sizeof(glm::mat4));
+ vkcv::PushConstants voxelVisualisationPushConstants (sizeof(glm::mat4));
+ voxelVisualisationPushConstants.appendDrawcall(viewProjectin);
mipLevel = std::clamp(mipLevel, (uint32_t)0, m_voxelImage.getMipCount()-1);
@@ -292,17 +338,45 @@ 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,
m_visualisationPipe,
- voxelVisualisationPushConstantData,
+ voxelVisualisationPushConstants,
{ drawcall },
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 309c75d5cad862ed8bbd43cfd001c05a660caeec..ca9951490e57b4b6afa3bbee986a55342a40582e 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,18 +27,58 @@ 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);
- window.initEvents();
-
vkcv::Core core = vkcv::Core::create(
window,
applicationName,
@@ -67,7 +111,7 @@ int main(int argc, const char** argv) {
std::vector<std::vector<vkcv::VertexBufferBinding>> vertexBufferBindings;
std::vector<vkcv::asset::VertexAttribute> vAttributes;
- for (int i = 0; i < scene.vertexGroups.size(); i++) {
+ for (size_t i = 0; i < scene.vertexGroups.size(); i++) {
vBuffers.push_back(scene.vertexGroups[i].vertexBuffer.data);
iBuffers.push_back(scene.vertexGroups[i].indexBuffer.data);
@@ -116,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;
@@ -143,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,
@@ -181,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),
@@ -216,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);
@@ -234,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::AttachmentDescription skyColorAttachment(
+ vkcv::AttachmentOperation::STORE,
+ vkcv::AttachmentOperation::LOAD,
+ colorBufferFormat);
- const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
+ const vkcv::AttachmentDescription skyDepthAttachments(
+ vkcv::AttachmentOperation::STORE,
+ vkcv::AttachmentOperation::LOAD,
+ depthBufferFormat);
- vkcv::ShaderProgram shadowShader;
- compiler.compile(vkcv::ShaderStage::VERTEX, "resources/shaders/shadow.vert",
+ vkcv::PassConfig skyPassConfig({ skyColorAttachment, skyDepthAttachments }, msaa);
+ vkcv::PassHandle skyPass = core.createPass(skyPassConfig);
+
+ 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();
- std::vector<std::array<glm::mat4, 2>> mainPassMatrices;
- std::vector<glm::mat4> mvpLight;
+ vkcv::ImageHandle resolvedColorBuffer;
+ if (usingMsaa) {
+ resolvedColorBuffer = core.createImage(colorBufferFormat, windowWidth, windowHeight, 1, false, true, true).getHandle();
+ }
+ else {
+ resolvedColorBuffer = colorBuffer;
+ }
+
+ const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
bool renderVoxelVis = false;
window.e_key.add([&renderVoxelVis](int key ,int scancode, int action, int mods) {
@@ -275,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));
@@ -295,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);
+ for (size_t i = 0; i < scene.vertexGroups.size(); i++) {
+ 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;
- for (int i = 0; i < meshes.size(); i++) {
+ std::vector<vkcv::DrawcallInfo> prepassDrawcalls;
+ for (size_t 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;
@@ -322,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;
@@ -343,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();
@@ -355,118 +573,226 @@ 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();
+
+ vkcv::PushConstants prepassPushConstants (sizeof(glm::mat4));
+
+ std::vector<glm::mat4> prepassMatrices;
for (const auto& m : modelMatrices) {
- mainPassMatrices.push_back({ viewProjectionCamera * m, m });
- mvpLight.push_back(lightInfo.lightMatrix * m);
+ prepassPushConstants.appendDrawcall(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));
-
- auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
+
+ const std::vector<vkcv::ImageHandle> prepassRenderTargets = { depthBuffer };
- // shadow map
core.recordDrawcallsToCmdStream(
cmdStream,
- shadowPass,
- shadowPipe,
- shadowPushConstantData,
- shadowDrawcalls,
- { shadowMap.getHandle() });
- core.prepareImageForSampling(cmdStream, shadowMap.getHandle());
+ prepassPass,
+ prepassPipeline,
+ prepassPushConstants,
+ prepassDrawcalls,
+ prepassRenderTargets);
+
+ core.recordImageMemoryBarrier(cmdStream, depthBuffer);
+
+ vkcv::PushConstants pushConstants (2 * sizeof(glm::mat4));
+
+ // main pass
+ for (const auto& m : modelMatrices) {
+ pushConstants.appendDrawcall(std::array<glm::mat4, 2>{ viewProjectionCamera * m, m });
+ }
- voxelization.setVoxelExtent(voxelizationExtent);
- voxelization.voxelizeMeshes(
- cmdStream,
- cameraManager.getActiveCamera().getPosition(),
- meshes,
- modelMatrices,
- perMeshDescriptorSets);
+ VolumetricSettings volumeSettings;
+ volumeSettings.scatteringCoefficient = scatteringColor * scatteringDensity;
+ volumeSettings.absorptionCoefficient = absorptionColor * absorptionDensity;
+ volumeSettings.ambientLight = volumetricAmbient;
+ volumetricSettingsBuffer.fill({ volumeSettings });
+
+ const std::vector<vkcv::ImageHandle> renderTargets = { colorBuffer, depthBuffer };
- // main pass
core.recordDrawcallsToCmdStream(
cmdStream,
- forwardPass,
- forwardPipeline,
- pushConstantData,
+ forwardPass,
+ forwardPipeline,
+ pushConstants,
drawcalls,
renderTargets);
if (renderVoxelVis) {
voxelization.renderVoxelVisualisation(cmdStream, viewProjectionCamera, renderTargets, voxelVisualisationMip);
}
+
+ vkcv::PushConstants skySettingsPushConstants (sizeof(skySettings));
+ skySettingsPushConstants.appendDrawcall(skySettings);
+
+ // sky
+ core.recordDrawcallsToCmdStream(
+ cmdStream,
+ skyPass,
+ skyPipe,
+ skySettingsPushConstants,
+ { vkcv::DrawcallInfo(vkcv::Mesh({}, nullptr, 3), {}) },
+ renderTargets);
- 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))),
+ 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::PushConstants(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;
+
+ vkcv::PushConstants timePushConstants (sizeof(timeF));
+ timePushConstants.appendDrawcall(timeF);
+
core.recordComputeDispatchToCmdStream(
cmdStream,
tonemappingPipeline,
- tonemappingDispatchCount,
+ fulsscreenDispatchCount,
{ vkcv::DescriptorSetUsage(0, core.getDescriptorSet(tonemappingDescriptorSet).vulkanHandle) },
- vkcv::PushConstantData(nullptr, 0));
+ timePushConstants);
// 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/BufferManager.cpp b/src/vkcv/BufferManager.cpp
index aec96411c5d9e07f200b24fbdcf9fa69e2af53d5..cfa233290b89702f196ed97c706254e002a0551b 100644
--- a/src/vkcv/BufferManager.cpp
+++ b/src/vkcv/BufferManager.cpp
@@ -28,32 +28,6 @@ namespace vkcv {
}
}
- /**
- * @brief searches memory type index for buffer allocation, combines requirements of buffer and application
- * @param physicalMemoryProperties Memory Properties of physical device
- * @param typeBits Bit field for suitable memory types
- * @param requirements Property flags that are required
- * @return memory type index for Buffer
- */
- uint32_t searchBufferMemoryType(const vk::PhysicalDeviceMemoryProperties& physicalMemoryProperties, uint32_t typeBits, vk::MemoryPropertyFlags requirements) {
- const uint32_t memoryCount = physicalMemoryProperties.memoryTypeCount;
- for (uint32_t memoryIndex = 0; memoryIndex < memoryCount; ++memoryIndex) {
- const uint32_t memoryTypeBits = (1 << memoryIndex);
- const bool isRequiredMemoryType = typeBits & memoryTypeBits;
-
- const vk::MemoryPropertyFlags properties =
- physicalMemoryProperties.memoryTypes[memoryIndex].propertyFlags;
- const bool hasRequiredProperties =
- (properties & requirements) == requirements;
-
- if (isRequiredMemoryType && hasRequiredProperties)
- return static_cast<int32_t>(memoryIndex);
- }
-
- // failed to find memory type
- return -1;
- }
-
BufferHandle BufferManager::createBuffer(BufferType type, size_t size, BufferMemoryType memoryType) {
vk::BufferCreateFlags createFlags;
vk::BufferUsageFlags usageFlags;
@@ -83,43 +57,48 @@ namespace vkcv {
usageFlags |= vk::BufferUsageFlagBits::eTransferDst;
}
- const vk::Device& device = m_core->getContext().getDevice();
-
- vk::Buffer buffer = device.createBuffer(
- vk::BufferCreateInfo(createFlags, size, usageFlags)
- );
-
- const vk::MemoryRequirements requirements = device.getBufferMemoryRequirements(buffer);
- const vk::PhysicalDevice& physicalDevice = m_core->getContext().getPhysicalDevice();
+ const vma::Allocator& allocator = m_core->getContext().getAllocator();
vk::MemoryPropertyFlags memoryTypeFlags;
+ vma::MemoryUsage memoryUsage;
bool mappable = false;
switch (memoryType) {
case BufferMemoryType::DEVICE_LOCAL:
memoryTypeFlags = vk::MemoryPropertyFlagBits::eDeviceLocal;
+ memoryUsage = vma::MemoryUsage::eGpuOnly;
+ mappable = false;
break;
case BufferMemoryType::HOST_VISIBLE:
memoryTypeFlags = vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent;
+ memoryUsage = vma::MemoryUsage::eCpuOnly;
mappable = true;
break;
default:
- // TODO: maybe an issue
+ vkcv_log(LogLevel::WARNING, "Unknown buffer memory type");
+ memoryUsage = vma::MemoryUsage::eUnknown;
+ mappable = false;
break;
}
- const uint32_t memoryTypeIndex = searchBufferMemoryType(
- physicalDevice.getMemoryProperties(),
- requirements.memoryTypeBits,
- memoryTypeFlags
+ auto bufferAllocation = allocator.createBuffer(
+ vk::BufferCreateInfo(createFlags, size, usageFlags),
+ vma::AllocationCreateInfo(
+ vma::AllocationCreateFlags(),
+ memoryUsage,
+ memoryTypeFlags,
+ memoryTypeFlags,
+ 0,
+ vma::Pool(),
+ nullptr
+ )
);
- vk::DeviceMemory memory = device.allocateMemory(vk::MemoryAllocateInfo(requirements.size, memoryTypeIndex));
-
- device.bindBufferMemory(buffer, memory, 0);
+ vk::Buffer buffer = bufferAllocation.first;
+ vma::Allocation allocation = bufferAllocation.second;
const uint64_t id = m_buffers.size();
- m_buffers.push_back({ buffer, memory, size, nullptr, mappable });
+ m_buffers.push_back({ buffer, allocation, size, mappable });
return BufferHandle(id, [&](uint64_t id) { destroyBufferById(id); });
}
@@ -130,7 +109,7 @@ namespace vkcv {
vk::Buffer buffer;
vk::Buffer stagingBuffer;
- vk::DeviceMemory stagingMemory;
+ vma::Allocation stagingAllocation;
size_t stagingLimit;
size_t stagingPosition;
@@ -150,11 +129,11 @@ namespace vkcv {
const size_t remaining = info.size - info.stagingPosition;
const size_t mapped_size = std::min(remaining, info.stagingLimit);
- const vk::Device& device = core->getContext().getDevice();
+ const vma::Allocator& allocator = core->getContext().getAllocator();
- void* mapped = device.mapMemory(info.stagingMemory, 0, mapped_size);
+ void* mapped = allocator.mapMemory(info.stagingAllocation);
memcpy(mapped, reinterpret_cast<const char*>(info.data) + info.stagingPosition, mapped_size);
- device.unmapMemory(info.stagingMemory);
+ allocator.unmapMemory(info.stagingAllocation);
SubmitInfo submitInfo;
submitInfo.queueType = QueueType::Transfer;
@@ -216,7 +195,13 @@ namespace vkcv {
auto& buffer = m_buffers[id];
- return buffer.m_memory;
+ const vma::Allocator& allocator = m_core->getContext().getAllocator();
+
+ auto info = allocator.getAllocationInfo(
+ buffer.m_allocation
+ );
+
+ return info.deviceMemory;
}
void BufferManager::fillBuffer(const BufferHandle& handle, const void *data, size_t size, size_t offset) {
@@ -232,11 +217,7 @@ namespace vkcv {
auto& buffer = m_buffers[id];
- if (buffer.m_mapped) {
- return;
- }
-
- const vk::Device& device = m_core->getContext().getDevice();
+ const vma::Allocator& allocator = m_core->getContext().getAllocator();
if (offset > buffer.m_size) {
return;
@@ -245,9 +226,9 @@ namespace vkcv {
const size_t max_size = std::min(size, buffer.m_size - offset);
if (buffer.m_mappable) {
- void* mapped = device.mapMemory(buffer.m_memory, offset, max_size);
- memcpy(mapped, data, max_size);
- device.unmapMemory(buffer.m_memory);
+ void* mapped = allocator.mapMemory(buffer.m_allocation);
+ memcpy(reinterpret_cast<char*>(mapped) + offset, data, max_size);
+ allocator.unmapMemory(buffer.m_allocation);
} else {
auto& stagingBuffer = m_buffers[ m_stagingBuffer.getId() ];
@@ -258,11 +239,9 @@ namespace vkcv {
info.buffer = buffer.m_handle;
info.stagingBuffer = stagingBuffer.m_handle;
- info.stagingMemory = stagingBuffer.m_memory;
+ info.stagingAllocation = stagingBuffer.m_allocation;
- const vk::MemoryRequirements stagingRequirements = device.getBufferMemoryRequirements(stagingBuffer.m_handle);
-
- info.stagingLimit = stagingRequirements.size;
+ info.stagingLimit = stagingBuffer.m_size;
info.stagingPosition = 0;
copyFromStagingBuffer(m_core, info);
@@ -282,19 +261,13 @@ namespace vkcv {
auto& buffer = m_buffers[id];
- if (buffer.m_mapped) {
- return nullptr;
- }
-
- const vk::Device& device = m_core->getContext().getDevice();
+ const vma::Allocator& allocator = m_core->getContext().getAllocator();
if (offset > buffer.m_size) {
return nullptr;
}
- const size_t max_size = std::min(size, buffer.m_size - offset);
- buffer.m_mapped = device.mapMemory(buffer.m_memory, offset, max_size);
- return buffer.m_mapped;
+ return reinterpret_cast<char*>(allocator.mapMemory(buffer.m_allocation)) + offset;
}
void BufferManager::unmapBuffer(const BufferHandle& handle) {
@@ -306,14 +279,9 @@ namespace vkcv {
auto& buffer = m_buffers[id];
- if (buffer.m_mapped == nullptr) {
- return;
- }
-
- const vk::Device& device = m_core->getContext().getDevice();
+ const vma::Allocator& allocator = m_core->getContext().getAllocator();
- device.unmapMemory(buffer.m_memory);
- buffer.m_mapped = nullptr;
+ allocator.unmapMemory(buffer.m_allocation);
}
void BufferManager::destroyBufferById(uint64_t id) {
@@ -323,16 +291,13 @@ namespace vkcv {
auto& buffer = m_buffers[id];
- const vk::Device& device = m_core->getContext().getDevice();
-
- if (buffer.m_memory) {
- device.freeMemory(buffer.m_memory);
- buffer.m_memory = nullptr;
- }
+ const vma::Allocator& allocator = m_core->getContext().getAllocator();
if (buffer.m_handle) {
- device.destroyBuffer(buffer.m_handle);
+ allocator.destroyBuffer(buffer.m_handle, buffer.m_allocation);
+
buffer.m_handle = nullptr;
+ buffer.m_allocation = nullptr;
}
}
diff --git a/src/vkcv/CommandStreamManager.cpp b/src/vkcv/CommandStreamManager.cpp
index 5a5b359b912d9cef36e0b03379d7f0f6f0951381..52b73213dbc5837f6be4a2aa25c28615dccf5969 100644
--- a/src/vkcv/CommandStreamManager.cpp
+++ b/src/vkcv/CommandStreamManager.cpp
@@ -32,11 +32,10 @@ namespace vkcv {
// find unused stream
int unusedStreamIndex = -1;
- for (int i = 0; i < m_commandStreams.size(); i++) {
+ for (size_t i = 0; i < m_commandStreams.size(); i++) {
if (m_commandStreams[i].cmdBuffer) {
// still in use
- }
- else {
+ } else {
unusedStreamIndex = i;
break;
}
diff --git a/src/vkcv/Context.cpp b/src/vkcv/Context.cpp
index ac133d1affc81702ee1a19b3f66810e606bec58d..5db50869498600fa8e926c0feff2cb5fda1eb22e 100644
--- a/src/vkcv/Context.cpp
+++ b/src/vkcv/Context.cpp
@@ -9,11 +9,13 @@ namespace vkcv
m_Instance(other.m_Instance),
m_PhysicalDevice(other.m_PhysicalDevice),
m_Device(other.m_Device),
- m_QueueManager(other.m_QueueManager)
+ m_QueueManager(other.m_QueueManager),
+ m_Allocator(other.m_Allocator)
{
other.m_Instance = nullptr;
other.m_PhysicalDevice = nullptr;
other.m_Device = nullptr;
+ other.m_Allocator = nullptr;
}
Context & Context::operator=(Context &&other) noexcept
@@ -22,10 +24,12 @@ namespace vkcv
m_PhysicalDevice = other.m_PhysicalDevice;
m_Device = other.m_Device;
m_QueueManager = other.m_QueueManager;
+ m_Allocator = other.m_Allocator;
other.m_Instance = nullptr;
other.m_PhysicalDevice = nullptr;
other.m_Device = nullptr;
+ other.m_Allocator = nullptr;
return *this;
}
@@ -33,15 +37,18 @@ namespace vkcv
Context::Context(vk::Instance instance,
vk::PhysicalDevice physicalDevice,
vk::Device device,
- QueueManager&& queueManager) noexcept :
- m_Instance{instance},
- m_PhysicalDevice{physicalDevice},
- m_Device{device},
- m_QueueManager{queueManager}
+ QueueManager&& queueManager,
+ vma::Allocator&& allocator) noexcept :
+ m_Instance(instance),
+ m_PhysicalDevice(physicalDevice),
+ m_Device(device),
+ m_QueueManager(queueManager),
+ m_Allocator(allocator)
{}
Context::~Context() noexcept
{
+ m_Allocator.destroy();
m_Device.destroy();
m_Instance.destroy();
}
@@ -64,6 +71,10 @@ namespace vkcv
const QueueManager& Context::getQueueManager() const {
return m_QueueManager;
}
+
+ const vma::Allocator& Context::getAllocator() const {
+ return m_Allocator;
+ }
/**
* @brief The physical device is evaluated by three categories:
@@ -280,6 +291,7 @@ namespace vkcv
vk::PhysicalDeviceFeatures deviceFeatures;
deviceFeatures.fragmentStoresAndAtomics = true;
deviceFeatures.geometryShader = true;
+ deviceFeatures.depthClamp = true;
deviceCreateInfo.pEnabledFeatures = &deviceFeatures;
// Ablauf
@@ -289,9 +301,44 @@ namespace vkcv
vk::Device device = physicalDevice.createDevice(deviceCreateInfo);
- QueueManager queueManager = QueueManager::create(device, queuePairsGraphics, queuePairsCompute, queuePairsTransfer);
+ QueueManager queueManager = QueueManager::create(
+ device,
+ queuePairsGraphics,
+ queuePairsCompute,
+ queuePairsTransfer
+ );
+
+ const vma::AllocatorCreateInfo allocatorCreateInfo (
+ vma::AllocatorCreateFlags(),
+ physicalDevice,
+ device,
+ 0,
+ nullptr,
+ nullptr,
+ 0,
+ nullptr,
+ nullptr,
+ nullptr,
+ instance,
+
+ /* Uses default version when set to 0 (currently VK_VERSION_1_0):
+ *
+ * The reason for this is that the allocator restricts the allowed version
+ * to be at maximum VK_VERSION_1_1 which is already less than
+ * VK_HEADER_VERSION_COMPLETE at most platforms.
+ * */
+ 0
+ );
+
+ vma::Allocator allocator = vma::createAllocator(allocatorCreateInfo);
- return Context(instance, physicalDevice, device, std::move(queueManager));
+ return Context(
+ instance,
+ physicalDevice,
+ device,
+ std::move(queueManager),
+ std::move(allocator)
+ );
}
}
diff --git a/src/vkcv/Core.cpp b/src/vkcv/Core.cpp
index 1492b1afa563543e6a9eef380295bcb71fef58b8..a66c1e6220261679a85241fff42de08a57428d4c 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,12 +65,12 @@ 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();
- const int graphicQueueFamilyIndex = queueManager.getGraphicsQueues()[0].familyIndex;
const std::unordered_set<int> queueFamilySet = generateQueueFamilyIndexSet(queueManager);
const auto commandResources = createCommandResources(context.getDevice(), queueFamilySet);
const auto defaultSyncResources = createSyncResources(context.getDevice());
@@ -116,7 +145,6 @@ namespace vkcv
return m_PipelineManager->createComputePipeline(shaderProgram, descriptorSetLayouts);
}
-
PassHandle Core::createPass(const PassConfig &config)
{
return m_PassManager->createPass(config);
@@ -124,7 +152,6 @@ namespace vkcv
Result Core::acquireSwapchainImage() {
uint32_t imageIndex;
-
vk::Result result;
try {
@@ -135,13 +162,20 @@ namespace vkcv
nullptr,
&imageIndex, {}
);
- } catch (vk::OutOfDateKHRError e) {
+ } catch (const vk::OutOfDateKHRError& e) {
result = vk::Result::eErrorOutOfDateKHR;
+ } catch (const 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 +187,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 +222,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());
@@ -181,7 +231,7 @@ namespace vkcv
const CommandStreamHandle cmdStreamHandle,
const PassHandle renderpassHandle,
const PipelineHandle pipelineHandle,
- const PushConstantData &pushConstantData,
+ const PushConstants &pushConstants,
const std::vector<DrawcallInfo> &drawcalls,
const std::vector<ImageHandle> &renderTargets) {
@@ -217,7 +267,7 @@ namespace vkcv
const vk::Rect2D renderArea(vk::Offset2D(0, 0), vk::Extent2D(width, height));
std::vector<vk::ImageView> attachmentsViews;
- for (const ImageHandle handle : renderTargets) {
+ for (const ImageHandle& handle : renderTargets) {
vk::ImageView targetHandle;
const auto cmdBuffer = m_CommandStreamManager->getStreamCommandBuffer(cmdStreamHandle);
@@ -254,8 +304,6 @@ namespace vkcv
vk::Rect2D dynamicScissor({0, 0}, {width, height});
- auto &bufferManager = m_BufferManager;
-
SubmitInfo submitInfo;
submitInfo.queueType = QueueType::Graphics;
submitInfo.signalSemaphores = { m_SyncResources.renderFinished };
@@ -287,14 +335,13 @@ namespace vkcv
cmdBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline, {});
const PipelineConfig &pipeConfig = m_PipelineManager->getPipelineConfig(pipelineHandle);
- if(pipeConfig.m_UseDynamicViewport)
- {
+ if (pipeConfig.m_UseDynamicViewport) {
cmdBuffer.setViewport(0, 1, &dynamicViewport);
cmdBuffer.setScissor(0, 1, &dynamicScissor);
}
- for (int i = 0; i < drawcalls.size(); i++) {
- recordDrawcall(drawcalls[i], cmdBuffer, pipelineLayout, pushConstantData, i);
+ for (size_t i = 0; i < drawcalls.size(); i++) {
+ recordDrawcall(drawcalls[i], cmdBuffer, pipelineLayout, pushConstants, i);
}
cmdBuffer.endRenderPass();
@@ -313,7 +360,7 @@ namespace vkcv
PipelineHandle computePipeline,
const uint32_t dispatchCount[3],
const std::vector<DescriptorSetUsage>& descriptorSetUsages,
- const PushConstantData& pushConstantData) {
+ const PushConstants& pushConstants) {
auto submitFunction = [&](const vk::CommandBuffer& cmdBuffer) {
@@ -328,13 +375,13 @@ namespace vkcv
{ usage.vulkanHandle },
{});
}
- if (pushConstantData.sizePerDrawcall > 0) {
+ if (pushConstants.getSizePerDrawcall() > 0) {
cmdBuffer.pushConstants(
pipelineLayout,
vk::ShaderStageFlagBits::eCompute,
0,
- pushConstantData.sizePerDrawcall,
- pushConstantData.data);
+ pushConstants.getSizePerDrawcall(),
+ pushConstants.getData());
}
cmdBuffer.dispatch(dispatchCount[0], dispatchCount[1], dispatchCount[2]);
};
@@ -366,12 +413,19 @@ namespace vkcv
try {
result = queueManager.getPresentQueue().handle.presentKHR(presentInfo);
- } catch (vk::OutOfDateKHRError e) {
+ } catch (const vk::OutOfDateKHRError& e) {
result = vk::Result::eErrorOutOfDateKHR;
+ } catch (const 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();
}
}
@@ -405,8 +459,6 @@ namespace vkcv
}
CommandStreamHandle Core::createCommandStream(QueueType queueType) {
-
- const vk::Device& device = m_Context.getDevice();
const vkcv::Queue queue = getQueueForSubmit(queueType, m_Context.getQueueManager());
const vk::CommandPool cmdPool = chooseCmdPool(queue, m_CommandResources);
@@ -437,13 +489,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 +512,18 @@ namespace vkcv
depth,
mipCount,
supportStorage,
- supportColorAttachment);
+ supportColorAttachment,
+ multisampling);
+ }
+
+ uint32_t Core::getImageWidth(ImageHandle imageHandle)
+ {
+ return m_ImageManager->getImageWidth(imageHandle);
+ }
+
+ uint32_t Core::getImageHeight(ImageHandle imageHandle)
+ {
+ return m_ImageManager->getImageHeight(imageHandle);
}
DescriptorSetHandle Core::createDescriptorSet(const std::vector<DescriptorBinding>& bindings)
@@ -480,34 +544,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) {
@@ -539,6 +575,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/DescriptorManager.cpp b/src/vkcv/DescriptorManager.cpp
index 265532232304106f7271fdd445d52074b7c011a1..07ca97b5ade9b69eed724000d9c7b388818d6725 100644
--- a/src/vkcv/DescriptorManager.cpp
+++ b/src/vkcv/DescriptorManager.cpp
@@ -16,7 +16,8 @@ namespace vkcv
vk::DescriptorPoolSize(vk::DescriptorType::eUniformBuffer, 1000),
vk::DescriptorPoolSize(vk::DescriptorType::eStorageBuffer, 1000) };
- m_PoolInfo = vk::DescriptorPoolCreateInfo({},
+ m_PoolInfo = vk::DescriptorPoolCreateInfo(
+ vk::DescriptorPoolCreateFlagBits::eFreeDescriptorSet,
1000,
static_cast<uint32_t>(m_PoolSizes.size()),
m_PoolSizes.data());
@@ -29,9 +30,13 @@ namespace vkcv
for (uint64_t id = 0; id < m_DescriptorSets.size(); id++) {
destroyDescriptorSetById(id);
}
+
m_DescriptorSets.clear();
+
for (const auto &pool : m_Pools) {
- m_Device.destroy(pool);
+ if (pool) {
+ m_Device.destroy(pool);
+ }
}
}
@@ -40,12 +45,12 @@ namespace vkcv
std::vector<vk::DescriptorSetLayoutBinding> setBindings = {};
//create each set's binding
- for (uint32_t i = 0; i < bindings.size(); i++) {
+ for (auto binding : bindings) {
vk::DescriptorSetLayoutBinding descriptorSetLayoutBinding(
- bindings[i].bindingID,
- convertDescriptorTypeFlag(bindings[i].descriptorType),
- bindings[i].descriptorCount,
- convertShaderStageFlag(bindings[i].shaderStage));
+ binding.bindingID,
+ convertDescriptorTypeFlag(binding.descriptorType),
+ binding.descriptorCount,
+ convertShaderStageFlag(binding.shaderStage));
setBindings.push_back(descriptorSetLayoutBinding);
}
@@ -53,8 +58,7 @@ namespace vkcv
//create the descriptor set's layout from the bindings gathered above
vk::DescriptorSetLayoutCreateInfo layoutInfo({}, setBindings);
- if(m_Device.createDescriptorSetLayout(&layoutInfo, nullptr, &set.layout) != vk::Result::eSuccess)
- {
+ if (m_Device.createDescriptorSetLayout(&layoutInfo, nullptr, &set.layout) != vk::Result::eSuccess) {
vkcv_log(LogLevel::ERROR, "Failed to create descriptor set layout");
return DescriptorSetHandle();
};
@@ -70,6 +74,7 @@ namespace vkcv
allocInfo.setDescriptorPool(m_Pools.back());
result = m_Device.allocateDescriptorSets(&allocInfo, &set.vulkanHandle);
}
+
if (result != vk::Result::eSuccess) {
vkcv_log(LogLevel::ERROR, "Failed to create descriptor set (%s)",
vk::to_string(result).c_str());
@@ -78,6 +83,8 @@ namespace vkcv
return DescriptorSetHandle();
}
};
+
+ set.poolIndex = (m_Pools.size() - 1);
const uint64_t id = m_DescriptorSets.size();
@@ -107,10 +114,11 @@ namespace vkcv
std::vector<WriteDescriptorSetInfo> writeInfos;
for (const auto& write : writes.sampledImageWrites) {
+ vk::ImageLayout layout = write.useGeneralLayout ? vk::ImageLayout::eGeneral : vk::ImageLayout::eShaderReadOnlyOptimal;
const vk::DescriptorImageInfo imageInfo(
nullptr,
- imageManager.getVulkanImageView(write.image),
- vk::ImageLayout::eShaderReadOnlyOptimal
+ imageManager.getVulkanImageView(write.image, write.mipLevel),
+ layout
);
imageInfos.push_back(imageInfo);
@@ -276,17 +284,22 @@ namespace vkcv
m_Device.destroyDescriptorSetLayout(set.layout);
set.layout = nullptr;
}
- // FIXME: descriptor set itself not destroyed
+
+ if (set.vulkanHandle) {
+ m_Device.freeDescriptorSets(m_Pools[set.poolIndex], 1, &(set.vulkanHandle));
+ set.vulkanHandle = nullptr;
+ }
}
vk::DescriptorPool DescriptorManager::allocateDescriptorPool() {
vk::DescriptorPool pool;
- if (m_Device.createDescriptorPool(&m_PoolInfo, nullptr, &pool) != vk::Result::eSuccess)
- {
+ if (m_Device.createDescriptorPool(&m_PoolInfo, nullptr, &pool) != vk::Result::eSuccess) {
vkcv_log(LogLevel::WARNING, "Failed to allocate descriptor pool");
pool = nullptr;
- };
- m_Pools.push_back(pool);
+ } else {
+ m_Pools.push_back(pool);
+ }
+
return pool;
}
diff --git a/src/vkcv/DrawcallRecording.cpp b/src/vkcv/DrawcallRecording.cpp
index df7b7bbcb3fe278622cd160593eb750db00ec7b1..32ed00e98f7ef72f0c391f61924444c26844869b 100644
--- a/src/vkcv/DrawcallRecording.cpp
+++ b/src/vkcv/DrawcallRecording.cpp
@@ -6,7 +6,7 @@ namespace vkcv {
const DrawcallInfo &drawcall,
vk::CommandBuffer cmdBuffer,
vk::PipelineLayout pipelineLayout,
- const PushConstantData &pushConstantData,
+ const PushConstants &pushConstants,
const size_t drawcallIndex) {
for (uint32_t i = 0; i < drawcall.mesh.vertexBufferBindings.size(); i++) {
@@ -23,23 +23,21 @@ namespace vkcv {
nullptr);
}
- const size_t drawcallPushConstantOffset = drawcallIndex * pushConstantData.sizePerDrawcall;
- // 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 (pushConstants.getSizePerDrawcall() > 0) {
+ cmdBuffer.pushConstants(
+ pipelineLayout,
+ vk::ShaderStageFlagBits::eAll,
+ 0,
+ pushConstants.getSizePerDrawcall(),
+ pushConstants.getDrawcallData(drawcallIndex));
+ }
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/Handles.cpp b/src/vkcv/Handles.cpp
index 020489418c8e2db6ce2062d6fd20f06f90a05c37..65fc02dedeba39953c173103efe9b228f49e5d7f 100644
--- a/src/vkcv/Handles.cpp
+++ b/src/vkcv/Handles.cpp
@@ -1,5 +1,7 @@
#include "vkcv/Handles.hpp"
+#include <iostream>
+
namespace vkcv {
Handle::Handle() :
@@ -11,7 +13,7 @@ namespace vkcv {
{}
Handle::~Handle() {
- if ((m_rc) && (--(*m_rc) == 0)) {
+ if ((m_rc) && (*m_rc > 0) && (--(*m_rc) == 0)) {
if (m_destroy) {
m_destroy(m_id);
}
@@ -82,9 +84,9 @@ namespace vkcv {
std::ostream& operator << (std::ostream& out, const Handle& handle) {
if (handle) {
- return out << "[Handle: " << handle.getId() << ":" << handle.getRC() << "]";
+ return out << "[" << typeid(handle).name() << ": " << handle.getId() << ":" << handle.getRC() << "]";
} else {
- return out << "[Handle: none]";
+ return out << "[" << typeid(handle).name() << ": none]";
}
}
diff --git a/src/vkcv/Image.cpp b/src/vkcv/Image.cpp
index c48b015335e00f23a892bb96d3e89a2c0877ae61..15a2fc5240176742f50141407a3c72b531757ee9 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 {
@@ -53,7 +56,7 @@ namespace vkcv{
m_manager->switchImageLayoutImmediate(m_handle, newLayout);
}
- vkcv::ImageHandle Image::getHandle() const {
+ const vkcv::ImageHandle& Image::getHandle() const {
return m_handle;
}
@@ -61,7 +64,7 @@ namespace vkcv{
return m_manager->getImageMipCount(m_handle);
}
- void Image::fill(void *data, size_t size) {
+ void Image::fill(const void *data, size_t size) {
m_manager->fillImage(m_handle, data, size);
}
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..1cb6ad3a1187c08cf1aa014ae4ae259591f5c786 100644
--- a/src/vkcv/ImageManager.cpp
+++ b/src/vkcv/ImageManager.cpp
@@ -12,26 +12,6 @@
namespace vkcv {
- ImageManager::Image::Image(
- vk::Image handle,
- vk::DeviceMemory memory,
- std::vector<vk::ImageView> views,
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- vk::Format format,
- uint32_t layers)
- :
- m_handle(handle),
- m_memory(memory),
- m_viewPerMip(views),
- m_width(width),
- m_height(height),
- m_depth(depth),
- m_format(format),
- m_layers(layers)
- {}
-
/**
* @brief searches memory type index for image allocation, combines requirements of image and application
* @param physicalMemoryProperties Memory Properties of physical device
@@ -67,7 +47,8 @@ namespace vkcv {
for (uint64_t id = 0; id < m_images.size(); id++) {
destroyImageById(id);
}
- for (const auto swapchainImage : m_swapchainImages) {
+
+ for (const auto& swapchainImage : m_swapchainImages) {
for (const auto view : swapchainImage.m_viewPerMip) {
m_core->getContext().getDevice().destroy(view);
}
@@ -85,13 +66,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 +83,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;
}
@@ -114,7 +104,7 @@ namespace vkcv {
imageUsageFlags |= vk::ImageUsageFlagBits::eDepthStencilAttachment;
}
- const vk::Device& device = m_core->getContext().getDevice();
+ const vma::Allocator& allocator = m_core->getContext().getAllocator();
vk::ImageType imageType = vk::ImageType::e3D;
vk::ImageViewType imageViewType = vk::ImageViewType::e3D;
@@ -134,8 +124,6 @@ namespace vkcv {
imageViewType = vk::ImageViewType::e2D;
}
- vk::ImageTiling imageTiling = vk::ImageTiling::eOptimal;
-
if (!formatProperties.optimalTilingFeatures) {
if (!formatProperties.linearTilingFeatures)
return ImageHandle();
@@ -147,36 +135,39 @@ namespace vkcv {
physicalDevice.getImageFormatProperties(format, imageType, imageTiling, imageUsageFlags);
const uint32_t arrayLayers = std::min<uint32_t>(1, imageFormatProperties.maxArrayLayers);
-
- const vk::ImageCreateInfo imageCreateInfo(
+
+ vk::SampleCountFlagBits sampleCountFlag = msaaToVkSampleCountFlag(msaa);
+
+ const vk::ImageCreateInfo imageCreateInfo (
createFlags,
imageType,
format,
vk::Extent3D(width, height, depth),
mipCount,
arrayLayers,
- vk::SampleCountFlagBits::e1,
+ sampleCountFlag,
imageTiling,
imageUsageFlags,
vk::SharingMode::eExclusive,
{},
vk::ImageLayout::eUndefined
);
-
- vk::Image image = device.createImage(imageCreateInfo);
- const vk::MemoryRequirements requirements = device.getImageMemoryRequirements(image);
-
- vk::MemoryPropertyFlags memoryTypeFlags = vk::MemoryPropertyFlagBits::eDeviceLocal;
-
- const uint32_t memoryTypeIndex = searchImageMemoryType(
- physicalDevice.getMemoryProperties(),
- requirements.memoryTypeBits,
- memoryTypeFlags
+ auto imageAllocation = allocator.createImage(
+ imageCreateInfo,
+ vma::AllocationCreateInfo(
+ vma::AllocationCreateFlags(),
+ vma::MemoryUsage::eGpuOnly,
+ vk::MemoryPropertyFlagBits::eDeviceLocal,
+ vk::MemoryPropertyFlagBits::eDeviceLocal,
+ 0,
+ vma::Pool(),
+ nullptr
+ )
);
- vk::DeviceMemory memory = device.allocateMemory(vk::MemoryAllocateInfo(requirements.size, memoryTypeIndex));
- device.bindImageMemory(image, memory, 0);
+ vk::Image image = imageAllocation.first;
+ vma::Allocation allocation = imageAllocation.second;
vk::ImageAspectFlags aspectFlags;
@@ -186,8 +177,10 @@ namespace vkcv {
aspectFlags = vk::ImageAspectFlagBits::eColor;
}
+ const vk::Device& device = m_core->getContext().getDevice();
+
std::vector<vk::ImageView> views;
- for (int mip = 0; mip < mipCount; mip++) {
+ for (uint32_t mip = 0; mip < mipCount; mip++) {
const vk::ImageViewCreateInfo imageViewCreateInfo(
{},
image,
@@ -212,11 +205,11 @@ namespace vkcv {
}
const uint64_t id = m_images.size();
- m_images.push_back(Image(image, memory, views, width, height, depth, format, arrayLayers));
+ m_images.push_back({ image, allocation, views, width, height, depth, format, arrayLayers, vk::ImageLayout::eUndefined });
return ImageHandle(id, [&](uint64_t id) { destroyImageById(id); });
}
- ImageHandle ImageManager::createSwapchainImage() {
+ ImageHandle ImageManager::createSwapchainImage() const {
return ImageHandle::createSwapchainImageHandle();
}
@@ -252,10 +245,16 @@ namespace vkcv {
auto& image = m_images[id];
- return image.m_memory;
+ const vma::Allocator& allocator = m_core->getContext().getAllocator();
+
+ auto info = allocator.getAllocationInfo(
+ image.m_allocation
+ );
+
+ return info.deviceMemory;
}
- vk::ImageView ImageManager::getVulkanImageView(const ImageHandle &handle, const size_t mipLevel) const {
+ vk::ImageView ImageManager::getVulkanImageView(const ImageHandle &handle, size_t mipLevel) const {
if (handle.isSwapchainImage()) {
return m_swapchainImages[m_currentSwapchainInputImage].m_viewPerMip[0];
@@ -269,7 +268,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,13 +351,15 @@ 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;
}
}
- void ImageManager::fillImage(const ImageHandle& handle, void* data, size_t size)
+ void ImageManager::fillImage(const ImageHandle& handle, const void* data, size_t size)
{
const uint64_t id = handle.getId();
@@ -493,9 +494,6 @@ namespace vkcv {
}
void ImageManager::generateImageMipChainImmediate(const ImageHandle& handle) {
-
- const auto& device = m_core->getContext().getDevice();
-
SubmitInfo submitInfo;
submitInfo.queueType = QueueType::Graphics;
@@ -521,6 +519,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();
@@ -580,15 +615,14 @@ namespace vkcv {
view = nullptr;
}
}
-
- if (image.m_memory) {
- device.freeMemory(image.m_memory);
- image.m_memory = nullptr;
- }
+
+ const vma::Allocator& allocator = m_core->getContext().getAllocator();
if (image.m_handle) {
- device.destroyImage(image.m_handle);
+ allocator.destroyImage(image.m_handle, image.m_allocation);
+
image.m_handle = nullptr;
+ image.m_allocation = nullptr;
}
}
@@ -607,7 +641,6 @@ namespace vkcv {
uint32_t ImageManager::getImageMipCount(const ImageHandle& handle) const {
const uint64_t id = handle.getId();
- const bool isSwapchainFormat = handle.isSwapchainImage();
if (handle.isSwapchainImage()) {
return 1;
@@ -625,11 +658,11 @@ namespace vkcv {
m_currentSwapchainInputImage = index;
}
- void ImageManager::setSwapchainImages(const std::vector<vk::Image>& images, std::vector<vk::ImageView> views,
+ void ImageManager::setSwapchainImages(const std::vector<vk::Image>& images, const std::vector<vk::ImageView>& views,
uint32_t width, uint32_t height, vk::Format format) {
// destroy old views
- for (auto image : m_swapchainImages) {
+ for (const auto& image : m_swapchainImages) {
for (const auto& view : image.m_viewPerMip) {
m_core->getContext().getDevice().destroyImageView(view);
}
@@ -637,8 +670,18 @@ namespace vkcv {
assert(images.size() == views.size());
m_swapchainImages.clear();
- for (int i = 0; i < images.size(); i++) {
- m_swapchainImages.push_back(Image(images[i], nullptr, { views[i] }, width, height, 1, format, 1));
+ for (size_t i = 0; i < images.size(); i++) {
+ m_swapchainImages.push_back({
+ images[i],
+ nullptr,
+ { views[i] },
+ width,
+ height,
+ 1,
+ format,
+ 1,
+ vk::ImageLayout::eUndefined
+ });
}
}
diff --git a/src/vkcv/ImageManager.hpp b/src/vkcv/ImageManager.hpp
index ecba7eb5959c1d78a0be41e0b3ac555bffd92d95..646b3211f761f0c71596fc088b39b784d5f39a5c 100644
--- a/src/vkcv/ImageManager.hpp
+++ b/src/vkcv/ImageManager.hpp
@@ -6,9 +6,11 @@
*/
#include <vector>
#include <vulkan/vulkan.hpp>
+#include <vk_mem_alloc.hpp>
#include "vkcv/BufferManager.hpp"
#include "vkcv/Handles.hpp"
+#include "vkcv/ImageConfig.hpp"
namespace vkcv {
@@ -19,28 +21,16 @@ namespace vkcv {
struct Image
{
vk::Image m_handle;
- vk::DeviceMemory m_memory;
+ vma::Allocation m_allocation;
std::vector<vk::ImageView> m_viewPerMip;
- uint32_t m_width = 0;
- uint32_t m_height = 0;
- uint32_t m_depth = 0;
+ uint32_t m_width;
+ uint32_t m_height;
+ uint32_t m_depth;
vk::Format m_format;
- uint32_t m_layers = 1;
- vk::ImageLayout m_layout = vk::ImageLayout::eUndefined;
+ uint32_t m_layers;
+ vk::ImageLayout m_layout;
private:
- // struct is public so utility functions can access members, but only ImageManager can create Image
friend ImageManager;
- Image(
- vk::Image handle,
- vk::DeviceMemory memory,
- std::vector<vk::ImageView> views,
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- vk::Format format,
- uint32_t layers);
-
- Image();
};
private:
@@ -51,7 +41,7 @@ namespace vkcv {
std::vector<Image> m_swapchainImages;
int m_currentSwapchainInputImage;
- ImageManager(BufferManager& bufferManager) noexcept;
+ explicit ImageManager(BufferManager& bufferManager) noexcept;
/**
* Destroys and deallocates image represented by a given
@@ -72,15 +62,17 @@ 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();
+ [[nodiscard]]
+ ImageHandle createSwapchainImage() const;
[[nodiscard]]
vk::Image getVulkanImage(const ImageHandle& handle) const;
@@ -89,7 +81,7 @@ namespace vkcv {
vk::DeviceMemory getVulkanDeviceMemory(const ImageHandle& handle) const;
[[nodiscard]]
- vk::ImageView getVulkanImageView(const ImageHandle& handle, const size_t mipLevel = 0) const;
+ vk::ImageView getVulkanImageView(const ImageHandle& handle, size_t mipLevel = 0) const;
void switchImageLayoutImmediate(const ImageHandle& handle, vk::ImageLayout newLayout);
void recordImageLayoutTransition(
@@ -101,10 +93,11 @@ namespace vkcv {
const ImageHandle& handle,
vk::CommandBuffer cmdBuffer);
- void fillImage(const ImageHandle& handle, void* data, size_t size);
+ void fillImage(const ImageHandle& handle, const 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;
@@ -121,8 +114,9 @@ namespace vkcv {
uint32_t getImageMipCount(const ImageHandle& handle) const;
void setCurrentSwapchainImageIndex(int index);
- void setSwapchainImages(const std::vector<vk::Image>& images, std::vector<vk::ImageView> views,
- uint32_t width, uint32_t height, vk::Format format);
+
+ void setSwapchainImages(const std::vector<vk::Image>& images, const std::vector<vk::ImageView>& views,
+ uint32_t width, uint32_t height, vk::Format format);
};
}
\ No newline at end of file
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/QueueManager.cpp b/src/vkcv/QueueManager.cpp
index df6c74cccf6c4652adc6a4c78802f282ea6ae293..b4891c6be387b817b87f059f4155f5708d4f4710 100644
--- a/src/vkcv/QueueManager.cpp
+++ b/src/vkcv/QueueManager.cpp
@@ -51,7 +51,7 @@ namespace vkcv {
}
//resort flags with heighest priority before allocating the queues
std::vector<vk::QueueFlagBits> newFlags;
- for(int i = 0; i < prios.size(); i++) {
+ for(size_t i = 0; i < prios.size(); i++) {
auto minElem = std::min_element(prios.begin(), prios.end());
int index = minElem - prios.begin();
newFlags.push_back(queueFlags[index]);
@@ -79,7 +79,7 @@ namespace vkcv {
switch (qFlag) {
case vk::QueueFlagBits::eGraphics:
found = false;
- for (int i = 0; i < queueFamilyStatus.size() && !found; i++) {
+ for (size_t i = 0; i < queueFamilyStatus.size() && !found; i++) {
if (queueFamilyStatus[i][0] > 0) {
queuePairsGraphics.push_back(std::pair(i, initialQueueFamilyStatus[i][0] - queueFamilyStatus[i][0]));
queueFamilyStatus[i][0]--;
@@ -89,7 +89,7 @@ namespace vkcv {
}
}
if (!found) {
- for (int i = 0; i < queueFamilyStatus.size() && !found; i++) {
+ for (size_t i = 0; i < queueFamilyStatus.size() && !found; i++) {
if (initialQueueFamilyStatus[i][0] > 0) {
queuePairsGraphics.push_back(std::pair(i, 0));
found = true;
@@ -101,7 +101,7 @@ namespace vkcv {
break;
case vk::QueueFlagBits::eCompute:
found = false;
- for (int i = 0; i < queueFamilyStatus.size() && !found; i++) {
+ for (size_t i = 0; i < queueFamilyStatus.size() && !found; i++) {
if (queueFamilyStatus[i][1] > 0) {
queuePairsCompute.push_back(std::pair(i, initialQueueFamilyStatus[i][1] - queueFamilyStatus[i][1]));
queueFamilyStatus[i][0]--;
@@ -111,7 +111,7 @@ namespace vkcv {
}
}
if (!found) {
- for (int i = 0; i < queueFamilyStatus.size() && !found; i++) {
+ for (size_t i = 0; i < queueFamilyStatus.size() && !found; i++) {
if (initialQueueFamilyStatus[i][1] > 0) {
queuePairsCompute.push_back(std::pair(i, 0));
found = true;
@@ -123,7 +123,7 @@ namespace vkcv {
break;
case vk::QueueFlagBits::eTransfer:
found = false;
- for (int i = 0; i < queueFamilyStatus.size() && !found; i++) {
+ for (size_t i = 0; i < queueFamilyStatus.size() && !found; i++) {
if (queueFamilyStatus[i][2] > 0) {
queuePairsTransfer.push_back(std::pair(i, initialQueueFamilyStatus[i][2] - queueFamilyStatus[i][2]));
queueFamilyStatus[i][0]--;
@@ -133,7 +133,7 @@ namespace vkcv {
}
}
if (!found) {
- for (int i = 0; i < queueFamilyStatus.size() && !found; i++) {
+ for (size_t i = 0; i < queueFamilyStatus.size() && !found; i++) {
if (initialQueueFamilyStatus[i][2] > 0) {
queuePairsTransfer.push_back(std::pair(i, 0));
found = true;
@@ -149,7 +149,7 @@ namespace vkcv {
}
// create all requested queues
- for (int i = 0; i < qFamilyProperties.size(); i++) {
+ for (size_t i = 0; i < qFamilyProperties.size(); i++) {
uint32_t create = std::abs(initialQueueFamilyStatus[i][0] - queueFamilyStatus[i][0]);
if (create > 0) {
vk::DeviceQueueCreateInfo qCreateInfo(
diff --git a/src/vkcv/Swapchain.cpp b/src/vkcv/Swapchain.cpp
index 33714adac7cec7c1b5e0013387424c4f865454ab..d0aa26db9c661ea40caf06349a72cc9188e791a9 100644
--- a/src/vkcv/Swapchain.cpp
+++ b/src/vkcv/Swapchain.cpp
@@ -1,7 +1,6 @@
#include <vkcv/Swapchain.hpp>
#include <utility>
-#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
namespace vkcv
@@ -79,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));
@@ -98,18 +100,14 @@ namespace vkcv
* @return available Format
*/
vk::SurfaceFormatKHR chooseSurfaceFormat(vk::PhysicalDevice physicalDevice, vk::SurfaceKHR surface) {
- uint32_t formatCount;
- physicalDevice.getSurfaceFormatsKHR(surface, &formatCount, nullptr);
- std::vector<vk::SurfaceFormatKHR> availableFormats(formatCount);
- if (physicalDevice.getSurfaceFormatsKHR(surface, &formatCount, &availableFormats[0]) != vk::Result::eSuccess) {
- throw std::runtime_error("Failed to get surface formats");
- }
+ std::vector<vk::SurfaceFormatKHR> availableFormats = physicalDevice.getSurfaceFormatsKHR(surface);
for (const auto& availableFormat : availableFormats) {
if (availableFormat.format == vk::Format::eB8G8R8A8Unorm && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
return availableFormat;
}
}
+
return availableFormats[0];
}
@@ -120,12 +118,7 @@ namespace vkcv
* @return available PresentationMode
*/
vk::PresentModeKHR choosePresentMode(vk::PhysicalDevice physicalDevice, vk::SurfaceKHR surface) {
- uint32_t modeCount;
- physicalDevice.getSurfacePresentModesKHR( surface, &modeCount, nullptr );
- std::vector<vk::PresentModeKHR> availablePresentModes(modeCount);
- if (physicalDevice.getSurfacePresentModesKHR(surface, &modeCount, &availablePresentModes[0]) != vk::Result::eSuccess) {
- throw std::runtime_error("Failed to get presentation modes");
- }
+ std::vector<vk::PresentModeKHR> availablePresentModes = physicalDevice.getSurfacePresentModesKHR(surface);
for (const auto& availablePresentMode : availablePresentModes) {
if (availablePresentMode == vk::PresentModeKHR::eMailbox) {
@@ -143,12 +136,11 @@ namespace vkcv
* @return available ImageCount
*/
uint32_t chooseImageCount(vk::PhysicalDevice physicalDevice, vk::SurfaceKHR surface) {
- vk::SurfaceCapabilitiesKHR surfaceCapabilities;
- if(physicalDevice.getSurfaceCapabilitiesKHR(surface, &surfaceCapabilities) != vk::Result::eSuccess){
- throw std::runtime_error("cannot get surface capabilities. There is an issue with the surface.");
- }
-
- uint32_t imageCount = surfaceCapabilities.minImageCount + 1; // minImageCount should always be at least 2; set to 3 for triple buffering
+ vk::SurfaceCapabilitiesKHR surfaceCapabilities = physicalDevice.getSurfaceCapabilitiesKHR(surface);
+
+ // minImageCount should always be at least 2; set to 3 for triple buffering
+ uint32_t imageCount = surfaceCapabilities.minImageCount + 1;
+
// check if requested image count is supported
if (surfaceCapabilities.maxImageCount > 0 && imageCount > surfaceCapabilities.maxImageCount) {
imageCount = surfaceCapabilities.maxImageCount;
@@ -213,33 +205,43 @@ namespace vkcv
}
void Swapchain::updateSwapchain(const Context &context, const Window &window) {
- if (!m_RecreationRequired.exchange(false))
- return;
+ if (!m_RecreationRequired.exchange(false)) {
+ return;
+ }
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 2436619300c24f035cba727481dfce8e1b397c9b..025cb388c6880cc8132b454c799d39e2b530ceb3 100644
--- a/src/vkcv/Window.cpp
+++ b/src/vkcv/Window.cpp
@@ -5,65 +5,100 @@
*/
#include <GLFW/glfw3.h>
-
#include "vkcv/Window.hpp"
namespace vkcv {
- static uint32_t s_WindowCount = 0;
-
- Window::Window(GLFWwindow *window)
- : m_window(window) {
+ static std::vector<GLFWwindow*> s_Windows;
+
+ Window::Window(GLFWwindow *window) :
+ m_window(window),
+ e_mouseButton(true),
+ e_mouseMove(true),
+ e_mouseScroll(true),
+ e_resize(true),
+ e_key(true),
+ e_char(true),
+ e_gamepad(true)
+ {
+ glfwSetWindowUserPointer(m_window, this);
+
+ // combine Callbacks with Events
+ glfwSetMouseButtonCallback(m_window, Window::onMouseButtonEvent);
+ glfwSetCursorPosCallback(m_window, Window::onMouseMoveEvent);
+ glfwSetWindowSizeCallback(m_window, Window::onResize);
+ glfwSetKeyCallback(m_window, Window::onKeyEvent);
+ glfwSetScrollCallback(m_window, Window::onMouseScrollEvent);
+ glfwSetCharCallback(m_window, Window::onCharEvent);
}
Window::~Window() {
+ Window::e_mouseButton.unlock();
+ Window::e_mouseMove.unlock();
+ Window::e_mouseScroll.unlock();
+ Window::e_resize.unlock();
+ Window::e_key.unlock();
+ Window::e_char.unlock();
+ Window::e_gamepad.unlock();
+
+ s_Windows.erase(std::find(s_Windows.begin(), s_Windows.end(), m_window));
glfwDestroyWindow(m_window);
- s_WindowCount--;
- if(s_WindowCount == 0) {
+ if(s_Windows.empty()) {
glfwTerminate();
}
}
-
- GLFWwindow* Window::createGLFWWindow(const char *windowTitle, int width, int height, bool resizable) {
- if(s_WindowCount == 0) {
+
+ Window Window::create( const char *windowTitle, int width, int height, bool resizable) {
+ if(s_Windows.empty()) {
glfwInit();
}
- s_WindowCount++;
-
width = std::max(width, 1);
height = std::max(height, 1);
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
glfwWindowHint(GLFW_RESIZABLE, resizable ? GLFW_TRUE : GLFW_FALSE);
-
- return glfwCreateWindow(width, height, windowTitle, nullptr, nullptr);
- }
-
- Window Window::create( const char *windowTitle, int width, int height, bool resizable) {
- return Window(createGLFWWindow(windowTitle, width, height, resizable));
- }
-
- void Window::initEvents() {
- glfwSetWindowUserPointer(m_window, this);
-
- // combine Callbacks with Events
- glfwSetMouseButtonCallback(m_window, Window::onMouseButtonEvent);
-
- glfwSetCursorPosCallback(m_window, Window::onMouseMoveEvent);
-
- glfwSetWindowSizeCallback(m_window, Window::onResize);
-
- glfwSetKeyCallback(m_window, Window::onKeyEvent);
-
- glfwSetScrollCallback(m_window, Window::onMouseScrollEvent);
+ GLFWwindow *window = glfwCreateWindow(width, height, windowTitle, nullptr, nullptr);
- glfwSetCharCallback(m_window, Window::onCharEvent);
+ s_Windows.push_back(window);
+
+ return Window(window);
}
void Window::pollEvents() {
+
+ for (auto glfwWindow : s_Windows) {
+ auto window = static_cast<Window *>(glfwGetWindowUserPointer(glfwWindow));
+
+ window->e_mouseButton.unlock();
+ window->e_mouseMove.unlock();
+ window->e_mouseScroll.unlock();
+ window->e_resize.unlock();
+ window->e_key.unlock();
+ window->e_char.unlock();
+ window->e_gamepad.unlock();
+ }
+
glfwPollEvents();
+
+ for (int gamepadIndex = GLFW_JOYSTICK_1; gamepadIndex <= GLFW_JOYSTICK_LAST; gamepadIndex++) {
+ if (glfwJoystickPresent(gamepadIndex)) {
+ onGamepadEvent(gamepadIndex);
+ }
+ }
+
+ for (auto glfwWindow : s_Windows) {
+ auto window = static_cast<Window *>(glfwGetWindowUserPointer(glfwWindow));
+
+ window->e_mouseButton.lock();
+ window->e_mouseMove.lock();
+ window->e_mouseScroll.lock();
+ window->e_resize.lock();
+ window->e_key.lock();
+ window->e_char.lock();
+ window->e_gamepad.lock();
+ }
}
void Window::onMouseButtonEvent(GLFWwindow *callbackWindow, int button, int action, int mods) {
@@ -114,6 +149,23 @@ namespace vkcv {
}
}
+ void Window::onGamepadEvent(int gamepadIndex) {
+ size_t activeWindowIndex = std::find_if(
+ s_Windows.begin(),
+ s_Windows.end(),
+ [](GLFWwindow* window){return glfwGetWindowAttrib(window, GLFW_FOCUSED);}
+ ) - s_Windows.begin();
+
+ // fixes index getting out of bounds (e.g. if there is no focused window)
+ activeWindowIndex *= (activeWindowIndex < s_Windows.size());
+
+ auto window = static_cast<Window *>(glfwGetWindowUserPointer(s_Windows[activeWindowIndex]));
+
+ if (window != nullptr) {
+ window->e_gamepad(gamepadIndex);
+ }
+ }
+
bool Window::isWindowOpen() const {
return !glfwWindowShouldClose(m_window);
}
@@ -133,4 +185,9 @@ namespace vkcv {
GLFWwindow *Window::getWindow() const {
return m_window;
}
-}
\ No newline at end of file
+
+ void Window::getFramebufferSize(int &width, int &height) const {
+ glfwGetFramebufferSize(m_window, &width, &height);
+ }
+
+}