diff --git a/config/Sources.cmake b/config/Sources.cmake
index 7632d7d8f788b53a22ce1a5b513f469a83b00f4d..4f673e00d1e42e733534480d6085affd651a8c04 100644
--- a/config/Sources.cmake
+++ b/config/Sources.cmake
@@ -29,6 +29,8 @@ set(vkcv_sources
${vkcv_source}/vkcv/ImageManager.hpp
${vkcv_source}/vkcv/ImageManager.cpp
+
+ ${vkcv_include}/vkcv/Logger.hpp
${vkcv_include}/vkcv/SwapChain.hpp
${vkcv_source}/vkcv/SwapChain.cpp
diff --git a/config/lib/SPIRV_Cross.cmake b/config/lib/SPIRV_Cross.cmake
index 751ee883c47e0eab081a13e5805ced6f2daa7e30..2e705d7d5a006e3851d14d22a57fd667c61c79f5 100644
--- a/config/lib/SPIRV_Cross.cmake
+++ b/config/lib/SPIRV_Cross.cmake
@@ -6,9 +6,20 @@ if (spirv-cross_FOUND)
message(${vkcv_config_msg} " SPIRV Cross - " ${SPIRV_CROSS_VERSION})
else()
if (EXISTS "${vkcv_lib_path}/SPIRV-Cross")
+ set(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS OFF CACHE INTERNAL "")
+ set(SPIRV_CROSS_SHARED OFF CACHE INTERNAL "")
+ set(SPIRV_CROSS_STATIC ON CACHE INTERNAL "")
set(SPIRV_CROSS_CLI OFF CACHE INTERNAL "")
set(SPIRV_CROSS_ENABLE_TESTS OFF CACHE INTERNAL "")
+
+ set(SPIRV_CROSS_ENABLE_GLSL ON CACHE INTERNAL "")
+ set(SPIRV_CROSS_ENABLE_HLSL OFF CACHE INTERNAL "")
+ set(SPIRV_CROSS_ENABLE_MSL OFF CACHE INTERNAL "")
+ set(SPIRV_CROSS_ENABLE_CPP ON CACHE INTERNAL "")
+ set(SPIRV_CROSS_ENABLE_REFLECT OFF CACHE INTERNAL "")
set(SPIRV_CROSS_ENABLE_C_API OFF CACHE INTERNAL "")
+ set(SPIRV_CROSS_ENABLE_UTIL OFF CACHE INTERNAL "")
+
set(SPIRV_CROSS_SKIP_INSTALL ON CACHE INTERNAL "")
add_subdirectory(${vkcv_lib}/SPIRV-Cross)
diff --git a/include/vkcv/Core.hpp b/include/vkcv/Core.hpp
index 061a2bd787b78f1af1e948b8a5b0486dff57e249..4f9468a2a738502d8459e4e136f566fa507d8b6e 100644
--- a/include/vkcv/Core.hpp
+++ b/include/vkcv/Core.hpp
@@ -157,6 +157,19 @@ namespace vkcv
[[nodiscard]]
PipelineHandle createGraphicsPipeline(const PipelineConfig &config);
+ /**
+ * Creates a basic vulkan compute pipeline using @p shader program and returns it using the @p handle.
+ * Fixed Functions for pipeline are set with standard values.
+ *
+ * @param shader program that hold the compiles compute shader
+ * @param handle a handle to return the created vulkan handle
+ * @return True if pipeline creation was successful, False if not
+ */
+ [[nodiscard]]
+ PipelineHandle createComputePipeline(
+ const ShaderProgram &config,
+ const std::vector<vk::DescriptorSetLayout> &descriptorSetLayouts);
+
/**
* Creates a basic vulkan render pass using @p config from the render pass config class and returns it using the @p handle.
* Fixed Functions for pipeline are set with standard values.
@@ -228,6 +241,13 @@ namespace vkcv
const std::vector<DrawcallInfo> &drawcalls,
const std::vector<ImageHandle> &renderTargets);
+ void recordComputeDispatchToCmdStream(
+ CommandStreamHandle cmdStream,
+ PipelineHandle computePipeline,
+ const uint32_t dispatchCount[3],
+ const std::vector<DescriptorSetUsage> &descriptorSetUsages,
+ const PushConstantData& pushConstantData);
+
/**
* @brief end recording and present image
*/
diff --git a/include/vkcv/Logger.hpp b/include/vkcv/Logger.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..251b6b528c45ea509dbfcd0cfb7135b77031f1ac
--- /dev/null
+++ b/include/vkcv/Logger.hpp
@@ -0,0 +1,68 @@
+#pragma once
+
+#include <iostream>
+
+namespace vkcv {
+
+ enum class LogLevel {
+ INFO,
+ WARNING,
+ ERROR
+ };
+
+ constexpr auto getLogOutput(LogLevel level) {
+ switch (level) {
+ case LogLevel::INFO:
+ return stdout;
+ default:
+ return stderr;
+ }
+ }
+
+ constexpr const char* getLogName(LogLevel level) {
+ switch (level) {
+ case LogLevel::INFO:
+ return "INFO";
+ case LogLevel::WARNING:
+ return "WARNING";
+ case LogLevel::ERROR:
+ return "ERROR";
+ default:
+ return "UNKNOWN";
+ }
+ }
+
+#ifndef NDEBUG
+#ifndef VKCV_DEBUG_MESSAGE_LEN
+#define VKCV_DEBUG_MESSAGE_LEN 1024
+#endif
+
+#ifdef _MSC_VER
+#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__ \
+ ); \
+}
+
+#else
+#define vkcv_log(level, ...) {}
+#endif
+
+}
diff --git a/modules/asset_loader/src/vkcv/asset/asset_loader.cpp b/modules/asset_loader/src/vkcv/asset/asset_loader.cpp
index e660b442d0b9a0208f95c9d753ef19e926bcac44..f3823cc8f3fe54b53835f356dd14a086515118dd 100644
--- a/modules/asset_loader/src/vkcv/asset/asset_loader.cpp
+++ b/modules/asset_loader/src/vkcv/asset/asset_loader.cpp
@@ -7,6 +7,8 @@
#define STBI_ONLY_JPEG
#include <stb_image.h>
+#include <vkcv/Logger.hpp>
+
namespace vkcv::asset {
/**
@@ -39,11 +41,12 @@ uint8_t convertTypeToInt(const fx::gltf::Accessor::Type type) {
* @param path path to file that is responsible for error
*/
void print_what (const std::exception& e, const std::string &path) {
- fprintf(stderr, "ERROR loading file %s: %s\n", path.c_str(), e.what());
+ vkcv_log(LogLevel::ERROR, "Loading file %s: %s",
+ path.c_str(), e.what());
+
try {
std::rethrow_if_nested(e);
} catch (const std::exception& nested) {
- std::cerr << "nested: ";
print_what(nested, path);
}
}
@@ -121,7 +124,7 @@ int loadMesh(const std::string &path, Mesh &mesh) {
const size_t off = indexBufferView.byteOffset;
const void *const ptr = ((char*)indexBuffer.data.data()) + off;
if (!memcpy(indexBufferData.data(), ptr, indexBufferView.byteLength)) {
- std::cerr << "ERROR copying index buffer data.\n";
+ vkcv_log(LogLevel::ERROR, "Copying index buffer data");
return 0;
}
}
@@ -136,7 +139,7 @@ int loadMesh(const std::string &path, Mesh &mesh) {
const size_t off = 0;
const void *const ptr = ((char*)vertexBuffer.data.data()) + off;
if (!memcpy(vertexBufferData.data(), ptr, vertexBuffer.byteLength)) {
- std::cerr << "ERROR copying vertex buffer data.\n";
+ vkcv_log(LogLevel::ERROR, "Copying vertex buffer data");
return 0;
}
}
@@ -150,9 +153,8 @@ int loadMesh(const std::string &path, Mesh &mesh) {
case fx::gltf::Accessor::ComponentType::UnsignedInt:
indexType = UINT32; break;
default:
- std::cerr << "ERROR: Index type not supported: " <<
- static_cast<uint16_t>(indexAccessor.componentType) <<
- std::endl;
+ vkcv_log(LogLevel::ERROR, "Index type (%u) not supported",
+ static_cast<uint16_t>(indexAccessor.componentType));
return 0;
}
diff --git a/projects/first_mesh/src/main.cpp b/projects/first_mesh/src/main.cpp
index 20638320a7d46d4f90fcfd2750dae440e466e28b..906b44c09dd4b84dc313527c8fb275b6dffbfe44 100644
--- a/projects/first_mesh/src/main.cpp
+++ b/projects/first_mesh/src/main.cpp
@@ -132,6 +132,7 @@ int main(int argc, const char** argv) {
vkcv::DescriptorWrites setWrites;
setWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(0, texture.getHandle()) };
setWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(1, sampler) };
+
core.writeDescriptorSet(descriptorSet, setWrites);
vkcv::ImageHandle depthBuffer = core.createImage(vk::Format::eD32Sfloat, windowWidth, windowHeight).getHandle();
diff --git a/projects/first_triangle/shaders/comp.spv b/projects/first_triangle/shaders/comp.spv
new file mode 100644
index 0000000000000000000000000000000000000000..b414e36b2bea66dab00746298e536d029091e0fd
Binary files /dev/null and b/projects/first_triangle/shaders/comp.spv differ
diff --git a/projects/first_triangle/shaders/compile.bat b/projects/first_triangle/shaders/compile.bat
index b4521235c40fe5fb163bab874560c2f219b7517f..17743a7c49cdfc6e091c43a42a0adb755a731682 100644
--- a/projects/first_triangle/shaders/compile.bat
+++ b/projects/first_triangle/shaders/compile.bat
@@ -1,3 +1,4 @@
%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/shader.comp b/projects/first_triangle/shaders/shader.comp
new file mode 100644
index 0000000000000000000000000000000000000000..fad6cd0815f2f09bf92dcc3171e2e3723f5466df
--- /dev/null
+++ b/projects/first_triangle/shaders/shader.comp
@@ -0,0 +1,25 @@
+#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/src/main.cpp b/projects/first_triangle/src/main.cpp
index 2ede653ff98e19159e0155b282cab1b309a13816..ca10434bb9e486649411bcaac54c432744a914bb 100644
--- a/projects/first_triangle/src/main.cpp
+++ b/projects/first_triangle/src/main.cpp
@@ -92,6 +92,7 @@ int main(int argc, const char** argv) {
return EXIT_FAILURE;
}
+ // Graphics Pipeline
vkcv::ShaderProgram triangleShaderProgram{};
triangleShaderProgram.addShader(vkcv::ShaderStage::VERTEX, std::filesystem::path("shaders/vert.spv"));
triangleShaderProgram.addShader(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("shaders/frag.spv"));
@@ -115,6 +116,30 @@ int main(int argc, const char** argv) {
return EXIT_FAILURE;
}
+ // Compute Pipeline
+ vkcv::ShaderProgram computeShaderProgram{};
+ computeShaderProgram.addShader(vkcv::ShaderStage::COMPUTE, std::filesystem::path("shaders/comp.spv"));
+ computeShaderProgram.reflectShader(vkcv::ShaderStage::COMPUTE);
+
+ // 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);
@@ -164,6 +189,17 @@ int main(int argc, const char** argv) {
pushConstantData,
{ 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);
diff --git a/src/vkcv/CommandResources.cpp b/src/vkcv/CommandResources.cpp
index 71c990c3c222f2318c2f5744ff6295f667d9e6f8..a31e6967d85bd099fe5cbbc865b0e062212ca16e 100644
--- a/src/vkcv/CommandResources.cpp
+++ b/src/vkcv/CommandResources.cpp
@@ -1,6 +1,7 @@
#include "vkcv/CommandResources.hpp"
#include <iostream>
+#include "vkcv/Logger.hpp"
namespace vkcv {
@@ -62,7 +63,7 @@ namespace vkcv {
return queueManager.getPresentQueue();
}
else {
- std::cerr << "getQueueForSubmit error: unknown queue type" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Unknown queue type");
return queueManager.getGraphicsQueues().front(); // graphics is the most general queue
}
}
diff --git a/src/vkcv/CommandStreamManager.cpp b/src/vkcv/CommandStreamManager.cpp
index 9d0a236a4eaa5a166be77d143370a018b9ea7e73..5a5b359b912d9cef36e0b03379d7f0f6f0951381 100644
--- a/src/vkcv/CommandStreamManager.cpp
+++ b/src/vkcv/CommandStreamManager.cpp
@@ -1,6 +1,8 @@
#include "vkcv/CommandStreamManager.hpp"
#include "vkcv/Core.hpp"
+#include "vkcv/Logger.hpp"
+
namespace vkcv {
CommandStreamManager::CommandStreamManager() noexcept : m_core(nullptr){}
@@ -14,7 +16,7 @@ namespace vkcv {
void CommandStreamManager::init(Core* core) {
if (!core) {
- std::cerr << "Error: CommandStreamManager::init requires valid core pointer" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Requires valid core pointer");
}
m_core = core;
}
@@ -57,7 +59,7 @@ namespace vkcv {
const size_t id = handle.getId();
if (id >= m_commandStreams.size()) {
- std::cerr << "Error: CommandStreamManager::recordCommandsToStream requires valid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Requires valid handle");
return;
}
@@ -71,7 +73,7 @@ namespace vkcv {
const size_t id = handle.getId();
if (id >= m_commandStreams.size()) {
- std::cerr << "Error: CommandStreamManager::addFinishCallbackToStream requires valid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Requires valid handle");
return;
}
@@ -86,7 +88,7 @@ namespace vkcv {
const size_t id = handle.getId();
if (id >= m_commandStreams.size()) {
- std::cerr << "Error: CommandStreamManager::submitCommandStreamSynchronous requires valid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Requires valid handle");
return;
}
CommandStream& stream = m_commandStreams[id];
@@ -111,7 +113,7 @@ namespace vkcv {
vk::CommandBuffer CommandStreamManager::getStreamCommandBuffer(const CommandStreamHandle handle) {
const size_t id = handle.getId();
if (id >= m_commandStreams.size()) {
- std::cerr << "Error: CommandStreamManager::submitCommandStreamSynchronous requires valid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Requires valid handle");
return nullptr;
}
return m_commandStreams[id].cmdBuffer;
diff --git a/src/vkcv/Core.cpp b/src/vkcv/Core.cpp
index 0d3bf032f5bc9e4997dabd90ae210166edd57160..e76a4111678ee5e9d506708a845c2a134d668d3a 100644
--- a/src/vkcv/Core.cpp
+++ b/src/vkcv/Core.cpp
@@ -16,6 +16,8 @@
#include "ImageLayoutTransitions.hpp"
#include "vkcv/CommandStreamManager.hpp"
+#include "vkcv/Logger.hpp"
+
namespace vkcv
{
@@ -101,6 +103,13 @@ namespace vkcv
return m_PipelineManager->createPipeline(config, *m_PassManager);
}
+ PipelineHandle Core::createComputePipeline(
+ const ShaderProgram &shaderProgram,
+ const std::vector<vk::DescriptorSetLayout>& descriptorSetLayouts)
+ {
+ return m_PipelineManager->createComputePipeline(shaderProgram, descriptorSetLayouts);
+ }
+
PassHandle Core::createPass(const PassConfig &config)
{
@@ -125,7 +134,7 @@ namespace vkcv
}
if (result != vk::Result::eSuccess) {
- std::cerr << vk::to_string(result) << std::endl;
+ vkcv_log(LogLevel::ERROR, "%s", vk::to_string(result).c_str());
return Result::ERROR;
}
@@ -149,7 +158,7 @@ namespace vkcv
}
if (acquireSwapchainImage() != Result::SUCCESS) {
- std::cerr << "Acquire failed!" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Acquire failed");
m_currentSwapchainImageIndex = std::numeric_limits<uint32_t>::max();
}
@@ -234,7 +243,7 @@ namespace vkcv
1);
if(m_Context.m_Device.createFramebuffer(&createInfo, nullptr, &framebuffer) != vk::Result::eSuccess)
{
- std::cout << "FAILED TO CREATE TEMPORARY FRAMEBUFFER!" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Failed to create temporary framebuffer");
return;
}
@@ -298,6 +307,40 @@ namespace vkcv
recordCommandsToStream(cmdStreamHandle, submitFunction, finishFunction);
}
+ void Core::recordComputeDispatchToCmdStream(
+ CommandStreamHandle cmdStreamHandle,
+ PipelineHandle computePipeline,
+ const uint32_t dispatchCount[3],
+ const std::vector<DescriptorSetUsage>& descriptorSetUsages,
+ const PushConstantData& pushConstantData) {
+
+ auto submitFunction = [&](const vk::CommandBuffer& cmdBuffer) {
+
+ const auto pipelineLayout = m_PipelineManager->getVkPipelineLayout(computePipeline);
+
+ cmdBuffer.bindPipeline(vk::PipelineBindPoint::eCompute, m_PipelineManager->getVkPipeline(computePipeline));
+ for (const auto& usage : descriptorSetUsages) {
+ cmdBuffer.bindDescriptorSets(
+ vk::PipelineBindPoint::eCompute,
+ pipelineLayout,
+ usage.setLocation,
+ { usage.vulkanHandle },
+ {});
+ }
+ if (pushConstantData.sizePerDrawcall > 0) {
+ cmdBuffer.pushConstants(
+ pipelineLayout,
+ vk::ShaderStageFlagBits::eCompute,
+ 0,
+ pushConstantData.sizePerDrawcall,
+ pushConstantData.data);
+ }
+ cmdBuffer.dispatch(dispatchCount[0], dispatchCount[1], dispatchCount[2]);
+ };
+
+ recordCommandsToStream(cmdStreamHandle, submitFunction, nullptr);
+ }
+
void Core::endFrame() {
if (m_currentSwapchainImageIndex == std::numeric_limits<uint32_t>::max()) {
return;
@@ -325,7 +368,7 @@ namespace vkcv
}
if (result != vk::Result::eSuccess) {
- std::cout << "Error: swapchain present failed... " << vk::to_string(result) << std::endl;
+ vkcv_log(LogLevel::ERROR, "Swapchain present failed (%s)", vk::to_string(result).c_str());
}
}
@@ -404,7 +447,7 @@ namespace vkcv
void Core::writeDescriptorSet(DescriptorSetHandle handle, const DescriptorWrites &writes) {
m_DescriptorManager->writeDescriptorSet(
- handle,
+ handle,
writes,
*m_ImageManager,
*m_BufferManager,
diff --git a/src/vkcv/DescriptorManager.cpp b/src/vkcv/DescriptorManager.cpp
index 5c14b928d1d3a8cf435564c2f95cc379b10f1650..f591daf90b47b57a758b2b24c7fa87b5c33e3c46 100644
--- a/src/vkcv/DescriptorManager.cpp
+++ b/src/vkcv/DescriptorManager.cpp
@@ -1,5 +1,7 @@
#include "DescriptorManager.hpp"
+#include "vkcv/Logger.hpp"
+
namespace vkcv
{
DescriptorManager::DescriptorManager(vk::Device device) noexcept:
@@ -53,7 +55,7 @@ namespace vkcv
vk::DescriptorSetLayoutCreateInfo layoutInfo({}, setBindings);
if(m_Device.createDescriptorSetLayout(&layoutInfo, nullptr, &set.layout) != vk::Result::eSuccess)
{
- std::cout << "FAILED TO CREATE DESCRIPTOR SET LAYOUT" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Failed to create descriptor set layout");
return DescriptorSetHandle();
};
@@ -69,10 +71,10 @@ namespace vkcv
result = m_Device.allocateDescriptorSets(&allocInfo, &set.vulkanHandle);
}
if (result != vk::Result::eSuccess) {
- std::cout << "FAILED TO ALLOCATE DESCRIPTOR SET" << std::endl;
- std::cout << vk::to_string(result) << std::endl;
+ vkcv_log(LogLevel::ERROR, "Failed to create descriptor set (%s)",
+ vk::to_string(result).c_str());
+
m_Device.destroy(set.layout);
-
return DescriptorSetHandle();
}
};
@@ -238,7 +240,7 @@ namespace vkcv
case DescriptorType::IMAGE_STORAGE:
return vk::DescriptorType::eStorageImage;
default:
- std::cerr << "Error: DescriptorManager::convertDescriptorTypeFlag, unknown DescriptorType" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Unknown DescriptorType");
return vk::DescriptorType::eUniformBuffer;
}
}
@@ -265,7 +267,7 @@ namespace vkcv
void DescriptorManager::destroyDescriptorSetById(uint64_t id) {
if (id >= m_DescriptorSets.size()) {
- std::cerr << "Error: DescriptorManager::destroyResourceDescriptionById invalid id" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid id");
return;
}
@@ -281,7 +283,7 @@ namespace vkcv
vk::DescriptorPool pool;
if (m_Device.createDescriptorPool(&m_PoolInfo, nullptr, &pool) != vk::Result::eSuccess)
{
- std::cout << "FAILED TO ALLOCATE DESCRIPTOR POOL." << std::endl;
+ vkcv_log(LogLevel::WARNING, "Failed to allocate descriptor pool");
pool = nullptr;
};
m_Pools.push_back(pool);
diff --git a/src/vkcv/ImageManager.cpp b/src/vkcv/ImageManager.cpp
index ca2901ab89ee876d0f74d8971267f19a46306c1e..2f713bbd07688fa63d80f3d9e11b614f1d15da39 100644
--- a/src/vkcv/ImageManager.cpp
+++ b/src/vkcv/ImageManager.cpp
@@ -6,6 +6,7 @@
#include "ImageManager.hpp"
#include "vkcv/Core.hpp"
#include "ImageLayoutTransitions.hpp"
+#include "vkcv/Logger.hpp"
#include <algorithm>
@@ -212,7 +213,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::getVulkanImage invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return nullptr;
}
@@ -225,7 +226,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::getVulkanDeviceMemory invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return nullptr;
}
@@ -238,7 +239,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::getVulkanImageView invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return nullptr;
}
@@ -251,7 +252,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::switchImageLayout invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return;
}
@@ -286,7 +287,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::switchImageLayout invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return;
}
@@ -329,7 +330,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::fillImage invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return;
}
@@ -403,7 +404,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::getImageWidth invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return 0;
}
@@ -416,7 +417,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::getImageHeight invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return 0;
}
@@ -429,7 +430,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::getImageDepth invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return 0;
}
@@ -441,7 +442,7 @@ namespace vkcv {
void ImageManager::destroyImageById(uint64_t id)
{
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::destroyImageById invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return;
}
@@ -470,7 +471,7 @@ namespace vkcv {
const uint64_t id = handle.getId();
if (id >= m_images.size()) {
- std::cerr << "Error: ImageManager::destroyImageById invalid handle" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Invalid handle");
return vk::Format::eUndefined;
}
diff --git a/src/vkcv/PipelineManager.cpp b/src/vkcv/PipelineManager.cpp
index 1971222aa424de084e30f5c574db77992b932ced..8de64c4261d5ff61f9a1175bb868c03e941a61a7 100644
--- a/src/vkcv/PipelineManager.cpp
+++ b/src/vkcv/PipelineManager.cpp
@@ -1,5 +1,6 @@
#include "PipelineManager.hpp"
#include "vkcv/Image.hpp"
+#include "vkcv/Logger.hpp"
namespace vkcv
{
@@ -20,15 +21,25 @@ namespace vkcv
// currently assuming default 32 bit formats, no lower precision or normalized variants supported
vk::Format vertexFormatToVulkanFormat(const VertexFormat format) {
switch (format) {
- case VertexFormat::FLOAT: return vk::Format::eR32Sfloat;
- case VertexFormat::FLOAT2: return vk::Format::eR32G32Sfloat;
- case VertexFormat::FLOAT3: return vk::Format::eR32G32B32Sfloat;
- case VertexFormat::FLOAT4: return vk::Format::eR32G32B32A32Sfloat;
- case VertexFormat::INT: return vk::Format::eR32Sint;
- case VertexFormat::INT2: return vk::Format::eR32G32Sint;
- case VertexFormat::INT3: return vk::Format::eR32G32B32Sint;
- case VertexFormat::INT4: return vk::Format::eR32G32B32A32Sint;
- default: std::cerr << "Warning: Unknown vertex format" << std::endl; return vk::Format::eUndefined;
+ case VertexFormat::FLOAT:
+ return vk::Format::eR32Sfloat;
+ case VertexFormat::FLOAT2:
+ return vk::Format::eR32G32Sfloat;
+ case VertexFormat::FLOAT3:
+ return vk::Format::eR32G32B32Sfloat;
+ case VertexFormat::FLOAT4:
+ return vk::Format::eR32G32B32A32Sfloat;
+ case VertexFormat::INT:
+ return vk::Format::eR32Sint;
+ case VertexFormat::INT2:
+ return vk::Format::eR32G32Sint;
+ case VertexFormat::INT3:
+ return vk::Format::eR32G32B32Sint;
+ case VertexFormat::INT4:
+ return vk::Format::eR32G32B32A32Sint;
+ default:
+ vkcv_log(LogLevel::WARNING, "Unknown vertex format");
+ return vk::Format::eUndefined;
}
}
@@ -49,7 +60,7 @@ namespace vkcv
const bool existsFragmentShader = config.m_ShaderProgram.existsShader(ShaderStage::FRAGMENT);
if (!(existsVertexShader && existsFragmentShader))
{
- std::cout << "Core::createGraphicsPipeline requires vertex and fragment shader code" << std::endl;
+ vkcv_log(LogLevel::ERROR, "Requires vertex and fragment shader code");
return PipelineHandle();
}
@@ -199,6 +210,7 @@ namespace vkcv
{},
(config.m_DescriptorLayouts),
(pushConstantRange));
+
vk::PipelineLayout vkPipelineLayout{};
if (m_Device.createPipelineLayout(&pipelineLayoutCreateInfo, nullptr, &vkPipelineLayout) != vk::Result::eSuccess)
{
@@ -352,4 +364,65 @@ namespace vkcv
return m_Configs.at(id);
}
+ PipelineHandle PipelineManager::createComputePipeline(
+ const ShaderProgram &shaderProgram,
+ const std::vector<vk::DescriptorSetLayout> &descriptorSetLayouts) {
+
+ // Temporally handing over the Shader Program instead of a pipeline config
+ vk::ShaderModule computeModule{};
+ if (createShaderModule(computeModule, shaderProgram, ShaderStage::COMPUTE) != vk::Result::eSuccess)
+ return PipelineHandle();
+
+ vk::PipelineShaderStageCreateInfo pipelineComputeShaderStageInfo(
+ {},
+ vk::ShaderStageFlagBits::eCompute,
+ computeModule,
+ "main",
+ nullptr
+ );
+
+ vk::PipelineLayoutCreateInfo pipelineLayoutCreateInfo({}, descriptorSetLayouts);
+
+ const size_t pushConstantSize = shaderProgram.getPushConstantSize();
+ vk::PushConstantRange pushConstantRange(vk::ShaderStageFlagBits::eCompute, 0, pushConstantSize);
+ if (pushConstantSize > 0) {
+ pipelineLayoutCreateInfo.setPushConstantRangeCount(1);
+ pipelineLayoutCreateInfo.setPPushConstantRanges(&pushConstantRange);
+ }
+
+ vk::PipelineLayout vkPipelineLayout{};
+ if (m_Device.createPipelineLayout(&pipelineLayoutCreateInfo, nullptr, &vkPipelineLayout) != vk::Result::eSuccess)
+ {
+ m_Device.destroy(computeModule);
+ return PipelineHandle();
+ }
+
+ vk::ComputePipelineCreateInfo computePipelineCreateInfo{};
+ computePipelineCreateInfo.stage = pipelineComputeShaderStageInfo;
+ computePipelineCreateInfo.layout = vkPipelineLayout;
+
+ vk::Pipeline vkPipeline;
+ if (m_Device.createComputePipelines(nullptr, 1, &computePipelineCreateInfo, nullptr, &vkPipeline)!= vk::Result::eSuccess)
+ {
+ m_Device.destroy(computeModule);
+ return PipelineHandle();
+ }
+
+ m_Device.destroy(computeModule);
+
+ const uint64_t id = m_Pipelines.size();
+ m_Pipelines.push_back({ vkPipeline, vkPipelineLayout });
+
+ return PipelineHandle(id, [&](uint64_t id) { destroyPipelineById(id); });
+ }
+
+ // There is an issue for refactoring the Pipeline Manager.
+ // While including Compute Pipeline Creation, some private helper functions where introduced:
+
+ vk::Result PipelineManager::createShaderModule(vk::ShaderModule &module, const ShaderProgram &shaderProgram, const ShaderStage stage)
+ {
+ std::vector<char> code = shaderProgram.getShader(stage).shaderCode;
+ vk::ShaderModuleCreateInfo moduleInfo({}, code.size(), reinterpret_cast<uint32_t*>(code.data()));
+ return m_Device.createShaderModule(&moduleInfo, nullptr, &module);
+ }
}
\ No newline at end of file
diff --git a/src/vkcv/PipelineManager.hpp b/src/vkcv/PipelineManager.hpp
index e243151f7248c07fa0287bb2eaf698e5080f7f61..634f5f4e6464532306e35fd10d9a1623df6ace16 100644
--- a/src/vkcv/PipelineManager.hpp
+++ b/src/vkcv/PipelineManager.hpp
@@ -21,7 +21,9 @@ namespace vkcv
std::vector<PipelineConfig> m_Configs;
void destroyPipelineById(uint64_t id);
-
+
+ vk::Result createShaderModule(vk::ShaderModule &module, const ShaderProgram &shaderProgram, ShaderStage stage);
+
public:
PipelineManager() = delete; // no default ctor
explicit PipelineManager(vk::Device device) noexcept; // ctor
@@ -35,6 +37,10 @@ namespace vkcv
PipelineHandle createPipeline(const PipelineConfig &config, PassManager& passManager);
+ PipelineHandle createComputePipeline(
+ const ShaderProgram& shaderProgram,
+ const std::vector<vk::DescriptorSetLayout>& descriptorSetLayouts);
+
[[nodiscard]]
vk::Pipeline getVkPipeline(const PipelineHandle &handle) const;
diff --git a/src/vkcv/QueueManager.cpp b/src/vkcv/QueueManager.cpp
index e4d1a2d3a3302fc435c4c278322c08f51f19be6b..df6c74cccf6c4652adc6a4c78802f282ea6ae293 100644
--- a/src/vkcv/QueueManager.cpp
+++ b/src/vkcv/QueueManager.cpp
@@ -4,7 +4,7 @@
#include <iostream>
#include "vkcv/QueueManager.hpp"
-
+#include "vkcv/Logger.hpp"
namespace vkcv {
@@ -95,7 +95,8 @@ namespace vkcv {
found = true;
}
}
- std::cerr << "Warning: not enough \"" << vk::to_string(qFlag) << "\"-Queues." << std::endl;
+
+ vkcv_log(LogLevel::WARNING, "Not enough %s queues", vk::to_string(qFlag).c_str());
}
break;
case vk::QueueFlagBits::eCompute:
@@ -116,7 +117,8 @@ namespace vkcv {
found = true;
}
}
- std::cerr << "Warning: not enough \"" << vk::to_string(qFlag) << "\"-Queues." << std::endl;
+
+ vkcv_log(LogLevel::WARNING, "Not enough %s queues", vk::to_string(qFlag).c_str());
}
break;
case vk::QueueFlagBits::eTransfer:
@@ -137,7 +139,8 @@ namespace vkcv {
found = true;
}
}
- std::cerr << "Warning: not enough \"" << vk::to_string(qFlag) << "\"-Queues." << std::endl;
+
+ vkcv_log(LogLevel::WARNING, "Not enough %s queues", vk::to_string(qFlag).c_str());
}
break;
default:
diff --git a/src/vkcv/ShaderProgram.cpp b/src/vkcv/ShaderProgram.cpp
index d22573d28d9a56908a373d6e3bbe0be9e87000ed..7c54c301d1301127273303128b0c10a9c2c53942 100644
--- a/src/vkcv/ShaderProgram.cpp
+++ b/src/vkcv/ShaderProgram.cpp
@@ -5,6 +5,7 @@
*/
#include "vkcv/ShaderProgram.hpp"
+#include "vkcv/Logger.hpp"
namespace vkcv {
/**
@@ -17,7 +18,7 @@ namespace vkcv {
{
std::ifstream file(shaderPath.string(), std::ios::ate | std::ios::binary);
if (!file.is_open()) {
- std::cout << "The file could not be opened." << std::endl;
+ vkcv_log(LogLevel::ERROR, "The file could not be opened");
return std::vector<char>{};
}
size_t fileSize = (size_t)file.tellg();
@@ -60,7 +61,8 @@ namespace vkcv {
default:
break;
}
- std::cout << "Shader Program Reflection: unknown Vertex Format" << std::endl;
+
+ vkcv_log(LogLevel::WARNING, "Unknown vertex format");
return VertexFormat::FLOAT;
}
@@ -72,14 +74,15 @@ namespace vkcv {
bool ShaderProgram::addShader(ShaderStage shaderStage, const std::filesystem::path &shaderPath)
{
- if(m_Shaders.find(shaderStage) != m_Shaders.end())
- std::cout << "Found existing shader stage. Overwriting." << std::endl;
+ if(m_Shaders.find(shaderStage) != m_Shaders.end()) {
+ vkcv_log(LogLevel::WARNING, "Overwriting existing shader stage");
+ }
const std::vector<char> shaderCode = readShaderCode(shaderPath);
- if (shaderCode.empty())
- return false;
- else
- {
+
+ if (shaderCode.empty()) {
+ return false;
+ } else {
Shader shader{shaderCode, shaderStage};
m_Shaders.insert(std::make_pair(shaderStage, shader));
return true;
diff --git a/src/vkcv/VertexLayout.cpp b/src/vkcv/VertexLayout.cpp
index 3a524d97865a06db3e8dbe22a390cafaee3a0226..3c39ad0d39c4b458526ceed54422d320ee6d0e0d 100644
--- a/src/vkcv/VertexLayout.cpp
+++ b/src/vkcv/VertexLayout.cpp
@@ -3,6 +3,7 @@
//
#include "vkcv/VertexLayout.hpp"
+#include "vkcv/Logger.hpp"
namespace vkcv {
uint32_t getFormatSize(VertexFormat format) {
@@ -24,10 +25,9 @@ namespace vkcv {
case VertexFormat::INT4:
return 16;
default:
- break;
+ vkcv_log(LogLevel::WARNING, "No format given");
+ return 0;
}
- std::cout << "VertexLayout: No format given" << std::endl;
- return 0;
}
VertexInputAttachment::VertexInputAttachment(uint32_t location, uint32_t binding, std::string name, VertexFormat format, uint32_t offset) noexcept: