projects/indirect_dispatch/src/App.cpp

+#include "App.hpp"
+#include "AppConfig.hpp"
+#include <chrono>
+#include <vkcv/gui/GUI.hpp>
+#include <functional>
+
+App::App() : 
+	m_applicationName("Indirect Dispatch"),
+	m_windowWidth(AppConfig::defaultWindowWidth),
+	m_windowHeight(AppConfig::defaultWindowHeight),
+	m_window(vkcv::Window::create(
+		m_applicationName,
+		m_windowWidth,
+		m_windowHeight,
+		true)),
+	m_core(vkcv::Core::create(
+		m_window,
+		m_applicationName,
+		VK_MAKE_VERSION(0, 0, 1),
+		{ vk::QueueFlagBits::eGraphics ,vk::QueueFlagBits::eCompute , vk::QueueFlagBits::eTransfer },
+		{},
+		{ "VK_KHR_swapchain" })),
+	m_cameraManager(m_window){}
+
+bool App::initialize() {
+
+	if (!loadMeshPass(m_core, &m_meshPass))
+		return false;
+
+	if (!loadSkyPass(m_core, &m_skyPass))
+		return false;
+
+	if (!loadPrePass(m_core, &m_prePass))
+		return false;
+
+	if (!loadSkyPrePass(m_core, &m_skyPrePass))
+		return false;
+
+	if (!loadComputePass(m_core, "resources/shaders/gammaCorrection.comp", &m_gammaCorrectionPass))
+		return false;
+
+	if (!loadMesh(m_core, "resources/models/cube.gltf", &m_cubeMesh))
+		return false;
+
+	if (!loadMesh(m_core, "resources/models/ground.gltf", &m_groundMesh))
+		return false;
+
+	if(!loadImage(m_core, "resources/models/grid.png", &m_gridTexture))
+		return false;
+
+	if (!m_motionBlur.initialize(&m_core, m_windowWidth, m_windowHeight))
+		return false;
+
+	m_linearSampler = m_core.createSampler(
+		vkcv::SamplerFilterType::LINEAR,
+		vkcv::SamplerFilterType::LINEAR,
+		vkcv::SamplerMipmapMode::LINEAR,
+		vkcv::SamplerAddressMode::CLAMP_TO_EDGE);
+
+	m_renderTargets = createRenderTargets(m_core, m_windowWidth, m_windowHeight);
+
+	const int cameraIndex = m_cameraManager.addCamera(vkcv::camera::ControllerType::PILOT);
+	m_cameraManager.getCamera(cameraIndex).setPosition(glm::vec3(0, 1, -3));
+	m_cameraManager.getCamera(cameraIndex).setNearFar(0.1f, 30.f);
+	
+	vkcv::DescriptorWrites meshPassDescriptorWrites;
+	meshPassDescriptorWrites.sampledImageWrites = { vkcv::SampledImageDescriptorWrite(0, m_gridTexture) };
+	meshPassDescriptorWrites.samplerWrites = { vkcv::SamplerDescriptorWrite(1, m_linearSampler) };
+	m_core.writeDescriptorSet(m_meshPass.descriptorSet, meshPassDescriptorWrites);
+
+	return true;
+}
+
+void App::run() {
+
+	auto                        frameStartTime = std::chrono::system_clock::now();
+	const auto                  appStartTime   = std::chrono::system_clock::now();
+	const vkcv::ImageHandle     swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
+	const vkcv::DrawcallInfo    skyDrawcall(m_cubeMesh.mesh, {}, 1);
+
+	vkcv::gui::GUI gui(m_core, m_window);
+
+	eMotionVectorVisualisationMode  motionVectorVisualisationMode   = eMotionVectorVisualisationMode::None;
+	eMotionBlurMode                 motionBlurMode                  = eMotionBlurMode::Default;
+
+	bool    freezeFrame                     = false;
+	float   motionBlurTileOffsetLength      = 3;
+	float   objectVerticalSpeed             = 5;
+	float   objectAmplitude                 = 0;
+	float   objectMeanHeight                = 1;
+	float   objectRotationSpeedX            = 5;
+	float   objectRotationSpeedY            = 5;
+	int     cameraShutterSpeedInverse       = 24;
+	float   motionVectorVisualisationRange  = 0.008;
+	float   motionBlurFastPathThreshold     = 1;
+
+	glm::mat4 viewProjection            = m_cameraManager.getActiveCamera().getMVP();
+	glm::mat4 viewProjectionPrevious    = m_cameraManager.getActiveCamera().getMVP();
+
+	struct Object {
+		MeshResources meshResources;
+		glm::mat4 modelMatrix   = glm::mat4(1.f);
+		glm::mat4 mvp           = glm::mat4(1.f);
+		glm::mat4 mvpPrevious   = glm::mat4(1.f);
+		std::function<void(float, Object&)> modelMatrixUpdate;
+	};
+	std::vector<Object> sceneObjects;
+
+	Object ground;
+	ground.meshResources = m_groundMesh;
+	sceneObjects.push_back(ground);
+
+	Object sphere;
+	sphere.meshResources = m_cubeMesh;
+	sphere.modelMatrixUpdate = [&](float time, Object& obj) {
+		const float currentHeight   = objectMeanHeight + objectAmplitude * glm::sin(time * objectVerticalSpeed);
+		const glm::mat4 translation = glm::translate(glm::mat4(1), glm::vec3(0, currentHeight, 0));
+		const glm::mat4 rotationX   = glm::rotate(glm::mat4(1), objectRotationSpeedX * time, glm::vec3(1, 0, 0));
+		const glm::mat4 rotationY   = glm::rotate(glm::mat4(1), objectRotationSpeedY * time, glm::vec3(0, 1, 0));
+		obj.modelMatrix             = translation * rotationX * rotationY;
+	};
+	sceneObjects.push_back(sphere);
+
+	bool spaceWasPressed = false;
+
+	m_window.e_key.add([&](int key, int scancode, int action, int mods) {
+		if (key == GLFW_KEY_SPACE) {
+			if (action == GLFW_PRESS) {
+				if (!spaceWasPressed) {
+					freezeFrame = !freezeFrame;
+				}
+				spaceWasPressed = true;
+			}
+			else if (action == GLFW_RELEASE) {
+				spaceWasPressed = false;
+			}
+		}
+	});
+
+	auto frameEndTime = std::chrono::system_clock::now();
+
+	while (m_window.isWindowOpen()) {
+
+		vkcv::Window::pollEvents();
+
+		if (!freezeFrame) {
+
+			frameStartTime          = frameEndTime;
+			viewProjectionPrevious  = viewProjection;
+
+			for (Object& obj : sceneObjects) {
+				obj.mvpPrevious = obj.mvp;
+			}
+		}
+
+		if (m_window.getHeight() == 0 || m_window.getWidth() == 0)
+			continue;
+
+		uint32_t swapchainWidth, swapchainHeight;
+		if (!m_core.beginFrame(swapchainWidth, swapchainHeight))
+			continue;
+
+		const bool hasResolutionChanged = (swapchainWidth != m_windowWidth) || (swapchainHeight != m_windowHeight);
+		if (hasResolutionChanged) {
+			m_windowWidth  = swapchainWidth;
+			m_windowHeight = swapchainHeight;
+
+			m_renderTargets = createRenderTargets(m_core, m_windowWidth, m_windowHeight);
+			m_motionBlur.setResolution(m_windowWidth, m_windowHeight);
+		}
+
+		if(!freezeFrame)
+			frameEndTime = std::chrono::system_clock::now();
+
+		const float microsecondToSecond = 0.000001;
+		const float fDeltaTimeSeconds = microsecondToSecond * std::chrono::duration_cast<std::chrono::microseconds>(frameEndTime - frameStartTime).count();
+
+		m_cameraManager.update(fDeltaTimeSeconds);
+
+		const auto      time                = frameEndTime - appStartTime;
+		const float     fCurrentTime        = std::chrono::duration_cast<std::chrono::milliseconds>(time).count() * 0.001f;
+
+		// update matrices
+		if (!freezeFrame) {
+
+			viewProjection = m_cameraManager.getActiveCamera().getMVP();
+
+			for (Object& obj : sceneObjects) {
+				if (obj.modelMatrixUpdate) {
+					obj.modelMatrixUpdate(fCurrentTime, obj);
+				}
+				obj.mvp = viewProjection * obj.modelMatrix;
+			}
+		}
+
+		const vkcv::CommandStreamHandle cmdStream = m_core.createCommandStream(vkcv::QueueType::Graphics);
+
+		// prepass
+		vkcv::PushConstants prepassPushConstants(sizeof(glm::mat4) * 2);
+
+		for (const Object& obj : sceneObjects) {
+			glm::mat4 prepassMatrices[2] = { obj.mvp, obj.mvpPrevious };
+			prepassPushConstants.appendDrawcall(prepassMatrices);
+		}
+
+		const std::vector<vkcv::ImageHandle> prepassRenderTargets = {
+			m_renderTargets.motionBuffer,
+			m_renderTargets.depthBuffer };
+
+		std::vector<vkcv::DrawcallInfo> prepassSceneDrawcalls;
+		for (const Object& obj : sceneObjects) {
+			prepassSceneDrawcalls.push_back(vkcv::DrawcallInfo(obj.meshResources.mesh, {}));
+		}
+
+		m_core.recordDrawcallsToCmdStream(
+			cmdStream,
+			m_prePass.renderPass,
+			m_prePass.pipeline,
+			prepassPushConstants,
+			prepassSceneDrawcalls,
+			prepassRenderTargets);
+
+		// sky prepass
+		glm::mat4 skyPrepassMatrices[2] = {
+			viewProjection,
+			viewProjectionPrevious };
+		vkcv::PushConstants skyPrepassPushConstants(sizeof(glm::mat4) * 2);
+		skyPrepassPushConstants.appendDrawcall(skyPrepassMatrices);
+
+		m_core.recordDrawcallsToCmdStream(
+			cmdStream,
+			m_skyPrePass.renderPass,
+			m_skyPrePass.pipeline,
+			skyPrepassPushConstants,
+			{ skyDrawcall },
+			prepassRenderTargets);
+
+		// main pass
+		const std::vector<vkcv::ImageHandle> renderTargets   = { 
+			m_renderTargets.colorBuffer, 
+			m_renderTargets.depthBuffer };
+
+		vkcv::PushConstants meshPushConstants(2 * sizeof(glm::mat4));
+		for (const Object& obj : sceneObjects) {
+			glm::mat4 matrices[2] = { obj.mvp, obj.modelMatrix };
+			meshPushConstants.appendDrawcall(matrices);
+		}
+
+		std::vector<vkcv::DrawcallInfo> forwardSceneDrawcalls;
+		for (const Object& obj : sceneObjects) {
+			forwardSceneDrawcalls.push_back(vkcv::DrawcallInfo(
+				obj.meshResources.mesh, 
+				{ vkcv::DescriptorSetUsage(0, m_core.getDescriptorSet(m_meshPass.descriptorSet).vulkanHandle) }));
+		}
+
+		m_core.recordDrawcallsToCmdStream(
+			cmdStream,
+			m_meshPass.renderPass,
+			m_meshPass.pipeline,
+			meshPushConstants,
+			forwardSceneDrawcalls,
+			renderTargets);
+
+		// sky
+		vkcv::PushConstants skyPushConstants(sizeof(glm::mat4));
+		skyPushConstants.appendDrawcall(viewProjection);
+
+		m_core.recordDrawcallsToCmdStream(
+			cmdStream,
+			m_skyPass.renderPass,
+			m_skyPass.pipeline,
+			skyPushConstants,
+			{ skyDrawcall },
+			renderTargets);
+
+		// motion blur
+		vkcv::ImageHandle motionBlurOutput;
+
+		if (motionVectorVisualisationMode == eMotionVectorVisualisationMode::None) {
+			float cameraNear;
+			float cameraFar;
+			m_cameraManager.getActiveCamera().getNearFar(cameraNear, cameraFar);
+
+			motionBlurOutput = m_motionBlur.render(
+				cmdStream,
+				m_renderTargets.motionBuffer,
+				m_renderTargets.colorBuffer,
+				m_renderTargets.depthBuffer,
+				motionBlurMode,
+				cameraNear,
+				cameraFar,
+				fDeltaTimeSeconds,
+				cameraShutterSpeedInverse,
+				motionBlurTileOffsetLength,
+				motionBlurFastPathThreshold);
+		}
+		else {
+			motionBlurOutput = m_motionBlur.renderMotionVectorVisualisation(
+				cmdStream,
+				m_renderTargets.motionBuffer,
+				motionVectorVisualisationMode,
+				motionVectorVisualisationRange);
+		}
+
+		// gamma correction
+		vkcv::DescriptorWrites gammaCorrectionDescriptorWrites;
+		gammaCorrectionDescriptorWrites.sampledImageWrites = {
+			vkcv::SampledImageDescriptorWrite(0, motionBlurOutput) };
+		gammaCorrectionDescriptorWrites.samplerWrites = {
+			vkcv::SamplerDescriptorWrite(1, m_linearSampler) };
+		gammaCorrectionDescriptorWrites.storageImageWrites = {
+			vkcv::StorageImageDescriptorWrite(2, swapchainInput) };
+
+		m_core.writeDescriptorSet(m_gammaCorrectionPass.descriptorSet, gammaCorrectionDescriptorWrites);
+
+		m_core.prepareImageForSampling(cmdStream, motionBlurOutput);
+		m_core.prepareImageForStorage (cmdStream, swapchainInput);
+
+		const uint32_t fullScreenImageDispatch[3] = {
+			static_cast<uint32_t>((m_windowWidth  + 7) / 8),
+			static_cast<uint32_t>((m_windowHeight + 7) / 8),
+			static_cast<uint32_t>(1) };
+
+		m_core.recordComputeDispatchToCmdStream(
+			cmdStream,
+			m_gammaCorrectionPass.pipeline,
+			fullScreenImageDispatch,
+			{ vkcv::DescriptorSetUsage(0, m_core.getDescriptorSet(m_gammaCorrectionPass.descriptorSet).vulkanHandle) },
+			vkcv::PushConstants(0));
+
+		m_core.prepareSwapchainImageForPresent(cmdStream);
+		m_core.submitCommandStream(cmdStream);
+
+		gui.beginGUI();
+		ImGui::Begin("Settings");
+
+		ImGui::Checkbox("Freeze frame", &freezeFrame);
+		ImGui::InputFloat("Motion tile offset length", &motionBlurTileOffsetLength);
+		ImGui::InputFloat("Motion blur fast path threshold", &motionBlurFastPathThreshold);
+
+		ImGui::Combo(
+			"Motion blur mode",
+			reinterpret_cast<int*>(&motionBlurMode),
+			MotionBlurModeLabels,
+			static_cast<int>(eMotionBlurMode::OptionCount));
+
+		ImGui::Combo(
+			"Debug view",
+			reinterpret_cast<int*>(&motionVectorVisualisationMode),
+			MotionVectorVisualisationModeLabels,
+			static_cast<int>(eMotionVectorVisualisationMode::OptionCount));
+
+		if (motionVectorVisualisationMode != eMotionVectorVisualisationMode::None)
+			ImGui::InputFloat("Motion vector visualisation range", &motionVectorVisualisationRange);
+
+		ImGui::InputInt("Camera shutter speed inverse", &cameraShutterSpeedInverse);
+
+		ImGui::InputFloat("Object movement speed",      &objectVerticalSpeed);
+		ImGui::InputFloat("Object movement amplitude",  &objectAmplitude);
+		ImGui::InputFloat("Object mean height",         &objectMeanHeight);
+		ImGui::InputFloat("Object rotation speed X",    &objectRotationSpeedX);
+		ImGui::InputFloat("Object rotation speed Y",    &objectRotationSpeedY);
+
+		ImGui::End();
+		gui.endGUI();
+
+		m_core.endFrame();
+	}
+}
\ No newline at end of file

projects/indirect_dispatch/src/App.hpp

+#pragma once
+#include <vkcv/Core.hpp>
+#include <vkcv/camera/CameraManager.hpp>
+#include "AppSetup.hpp"
+#include "MotionBlur.hpp"
+
+class App {
+public:
+	App();
+	bool initialize();
+	void run();
+private:
+	const char* m_applicationName;
+
+	int m_windowWidth;
+	int m_windowHeight;
+
+	vkcv::Window                m_window;
+	vkcv::Core                  m_core;
+	vkcv::camera::CameraManager m_cameraManager;
+
+	MotionBlur m_motionBlur;
+
+	vkcv::ImageHandle m_gridTexture;
+
+	MeshResources m_cubeMesh;
+	MeshResources m_groundMesh;
+
+	GraphicPassHandles m_meshPass;
+	GraphicPassHandles m_skyPass;
+	GraphicPassHandles m_prePass;
+	GraphicPassHandles m_skyPrePass;
+
+	ComputePassHandles m_gammaCorrectionPass;
+
+	AppRenderTargets    m_renderTargets;
+	vkcv::SamplerHandle m_linearSampler;
+};
\ No newline at end of file

projects/indirect_dispatch/src/AppConfig.hpp

+#pragma once
+#include "vulkan/vulkan.hpp"
+
+namespace AppConfig{
+	const int           defaultWindowWidth  = 1280;
+	const int           defaultWindowHeight = 720;
+	const vk::Format    depthBufferFormat   = vk::Format::eD32Sfloat;
+	const vk::Format    colorBufferFormat   = vk::Format::eB10G11R11UfloatPack32;
+	const vk::Format    motionBufferFormat  = vk::Format::eR16G16Sfloat;
+}
\ No newline at end of file

projects/indirect_dispatch/src/AppSetup.cpp

+#include "AppSetup.hpp"
+#include "AppConfig.hpp"
+#include <vkcv/asset/asset_loader.hpp>
+#include <vkcv/shader/GLSLCompiler.hpp>
+
+bool loadMesh(vkcv::Core& core, const std::filesystem::path& path, MeshResources* outMesh) {
+	assert(outMesh);
+
+	vkcv::asset::Scene scene;
+	const int meshLoadResult = vkcv::asset::loadScene(path.string(), scene);
+
+	if (meshLoadResult != 1) {
+		vkcv_log(vkcv::LogLevel::ERROR, "Mesh loading failed");
+		return false;
+	}
+
+	if (scene.meshes.size() < 1) {
+		vkcv_log(vkcv::LogLevel::ERROR, "Cube mesh scene does not contain any vertex groups");
+		return false;
+	}
+	assert(!scene.vertexGroups.empty());
+
+	auto& vertexData = scene.vertexGroups[0].vertexBuffer;
+	auto& indexData  = scene.vertexGroups[0].indexBuffer;
+
+	vkcv::Buffer vertexBuffer = core.createBuffer<uint8_t>(
+		vkcv::BufferType::VERTEX,
+		vertexData.data.size(),
+		vkcv::BufferMemoryType::DEVICE_LOCAL);
+
+	vkcv::Buffer indexBuffer = core.createBuffer<uint8_t>(
+		vkcv::BufferType::INDEX,
+		indexData.data.size(),
+		vkcv::BufferMemoryType::DEVICE_LOCAL);
+
+	vertexBuffer.fill(vertexData.data);
+	indexBuffer.fill(indexData.data);
+
+	outMesh->vertexBuffer = vertexBuffer.getHandle();
+	outMesh->indexBuffer  = indexBuffer.getHandle();
+
+	auto& attributes = vertexData.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(static_cast<vk::DeviceSize>(attributes[0].offset), vertexBuffer.getVulkanHandle()),
+		vkcv::VertexBufferBinding(static_cast<vk::DeviceSize>(attributes[1].offset), vertexBuffer.getVulkanHandle()),
+		vkcv::VertexBufferBinding(static_cast<vk::DeviceSize>(attributes[2].offset), vertexBuffer.getVulkanHandle()) };
+
+	outMesh->mesh = vkcv::Mesh(vertexBufferBindings, indexBuffer.getVulkanHandle(), scene.vertexGroups[0].numIndices);
+
+	return true;
+}
+
+bool loadImage(vkcv::Core& core, const std::filesystem::path& path, vkcv::ImageHandle* outImage) {
+
+	assert(outImage);
+
+	const vkcv::asset::Texture textureData = vkcv::asset::loadTexture(path);
+
+	if (textureData.channels != 4) {
+		vkcv_log(vkcv::LogLevel::ERROR, "Expecting image with four components");
+		return false;
+	}
+
+	vkcv::Image image = core.createImage(
+		vk::Format::eR8G8B8A8Srgb, 
+		textureData.width, 
+		textureData.height, 
+		1, 
+		true);
+
+	image.fill(textureData.data.data(), textureData.data.size());
+	image.generateMipChainImmediate();
+	image.switchLayout(vk::ImageLayout::eReadOnlyOptimalKHR);
+
+	*outImage = image.getHandle();
+	return true;
+}
+
+bool loadGraphicPass(
+	vkcv::Core& core,
+	const std::filesystem::path vertexPath,
+	const std::filesystem::path fragmentPath,
+	const vkcv::PassConfig&     passConfig,
+	const vkcv::DepthTest       depthTest,
+	GraphicPassHandles*         outPassHandles) {
+
+	assert(outPassHandles);
+
+	outPassHandles->renderPass = core.createPass(passConfig);
+
+	if (!outPassHandles->renderPass) {
+		vkcv_log(vkcv::LogLevel::ERROR, "Error: Could not create renderpass");
+		return false;
+	}
+
+	vkcv::ShaderProgram         shaderProgram;
+	vkcv::shader::GLSLCompiler  compiler;
+
+	compiler.compile(vkcv::ShaderStage::VERTEX, vertexPath,
+		[&shaderProgram](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+		shaderProgram.addShader(shaderStage, path);
+	});
+
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, fragmentPath,
+		[&shaderProgram](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+		shaderProgram.addShader(shaderStage, path);
+	});
+
+	const std::vector<vkcv::VertexAttachment> vertexAttachments = shaderProgram.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 vertexLayout(bindings);
+
+	const auto descriptorBindings = shaderProgram.getReflectedDescriptors();
+	const bool hasDescriptor = descriptorBindings.size() > 0;
+	if (hasDescriptor)
+		outPassHandles->descriptorSet = core.createDescriptorSet(descriptorBindings[0]);
+
+	std::vector<vk::DescriptorSetLayout> descriptorLayouts;
+	if (hasDescriptor)
+		descriptorLayouts.push_back(core.getDescriptorSet(outPassHandles->descriptorSet).layout);
+
+	vkcv::PipelineConfig pipelineConfig{
+		shaderProgram,
+		UINT32_MAX,
+		UINT32_MAX,
+		outPassHandles->renderPass,
+		{ vertexLayout },
+		descriptorLayouts,
+		true };
+	pipelineConfig.m_depthTest  = depthTest;
+	outPassHandles->pipeline    = core.createGraphicsPipeline(pipelineConfig);
+
+	if (!outPassHandles->pipeline) {
+		vkcv_log(vkcv::LogLevel::ERROR, "Error: Could not create graphics pipeline");
+		return false;
+	}
+
+	return true;
+}
+
+bool loadMeshPass(vkcv::Core& core, GraphicPassHandles* outHandles) {
+
+	assert(outHandles);
+
+	vkcv::AttachmentDescription colorAttachment(
+		vkcv::AttachmentOperation::STORE,
+		vkcv::AttachmentOperation::DONT_CARE,
+		AppConfig::colorBufferFormat);
+
+	vkcv::AttachmentDescription depthAttachment(
+		vkcv::AttachmentOperation::STORE,
+		vkcv::AttachmentOperation::LOAD,
+		AppConfig::depthBufferFormat);
+
+	return loadGraphicPass(
+		core,
+		"resources/shaders/mesh.vert",
+		"resources/shaders/mesh.frag",
+		vkcv::PassConfig({ colorAttachment, depthAttachment }),
+		vkcv::DepthTest::Equal,
+		outHandles);
+}
+
+bool loadSkyPass(vkcv::Core& core, GraphicPassHandles* outHandles) {
+
+	assert(outHandles);
+
+	vkcv::AttachmentDescription colorAttachment(
+		vkcv::AttachmentOperation::STORE,
+		vkcv::AttachmentOperation::LOAD,
+		AppConfig::colorBufferFormat);
+
+	vkcv::AttachmentDescription depthAttachment(
+		vkcv::AttachmentOperation::STORE,
+		vkcv::AttachmentOperation::LOAD,
+		AppConfig::depthBufferFormat);
+
+	return loadGraphicPass(
+		core,
+		"resources/shaders/sky.vert",
+		"resources/shaders/sky.frag",
+		vkcv::PassConfig({ colorAttachment, depthAttachment }),
+		vkcv::DepthTest::Equal,
+		outHandles);
+}
+
+bool loadPrePass(vkcv::Core& core, GraphicPassHandles* outHandles) {
+	assert(outHandles);
+
+	vkcv::AttachmentDescription motionAttachment(
+		vkcv::AttachmentOperation::STORE,
+		vkcv::AttachmentOperation::CLEAR,
+		AppConfig::motionBufferFormat);
+
+	vkcv::AttachmentDescription depthAttachment(
+		vkcv::AttachmentOperation::STORE,
+		vkcv::AttachmentOperation::CLEAR,
+		AppConfig::depthBufferFormat);
+
+	return loadGraphicPass(
+		core,
+		"resources/shaders/prepass.vert",
+		"resources/shaders/prepass.frag",
+		vkcv::PassConfig({ motionAttachment, depthAttachment }),
+		vkcv::DepthTest::LessEqual,
+		outHandles);
+}
+
+bool loadSkyPrePass(vkcv::Core& core, GraphicPassHandles* outHandles) {
+	assert(outHandles);
+
+	vkcv::AttachmentDescription motionAttachment(
+		vkcv::AttachmentOperation::STORE,
+		vkcv::AttachmentOperation::LOAD,
+		AppConfig::motionBufferFormat);
+
+	vkcv::AttachmentDescription depthAttachment(
+		vkcv::AttachmentOperation::STORE,
+		vkcv::AttachmentOperation::LOAD,
+		AppConfig::depthBufferFormat);
+
+	return loadGraphicPass(
+		core,
+		"resources/shaders/skyPrepass.vert",
+		"resources/shaders/skyPrepass.frag",
+		vkcv::PassConfig({ motionAttachment, depthAttachment }),
+		vkcv::DepthTest::LessEqual,
+		outHandles);
+}
+
+bool loadComputePass(vkcv::Core& core, const std::filesystem::path& path, ComputePassHandles* outComputePass) {
+
+	assert(outComputePass);
+	vkcv::ShaderProgram shaderProgram;
+	vkcv::shader::GLSLCompiler compiler;
+
+	compiler.compile(vkcv::ShaderStage::COMPUTE, path,
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
+		shaderProgram.addShader(shaderStage, path);
+	});
+
+	if (shaderProgram.getReflectedDescriptors().size() < 1) {
+		vkcv_log(vkcv::LogLevel::ERROR, "Compute shader has no descriptor set");
+		return false;
+	}
+
+	outComputePass->descriptorSet = core.createDescriptorSet(shaderProgram.getReflectedDescriptors()[0]);
+
+	outComputePass->pipeline = core.createComputePipeline(
+		shaderProgram,
+		{ core.getDescriptorSet(outComputePass->descriptorSet).layout });
+
+	if (!outComputePass->pipeline) {
+		vkcv_log(vkcv::LogLevel::ERROR, "Compute shader pipeline creation failed");
+		return false;
+	}
+
+	return true;
+}
+
+AppRenderTargets createRenderTargets(vkcv::Core& core, const uint32_t width, const uint32_t height) {
+
+	AppRenderTargets targets;
+
+	targets.depthBuffer = core.createImage(
+		AppConfig::depthBufferFormat,
+		width,
+		height,
+		1,
+		false).getHandle();
+
+	targets.colorBuffer = core.createImage(
+		AppConfig::colorBufferFormat,
+		width,
+		height,
+		1,
+		false,
+		false,
+		true).getHandle();
+
+	targets.motionBuffer = core.createImage(
+		AppConfig::motionBufferFormat,
+		width,
+		height,
+		1,
+		false,
+		false,
+		true).getHandle();
+
+	return targets;
+}
\ No newline at end of file

projects/indirect_dispatch/src/AppSetup.hpp

+#pragma once
+#include <vkcv/Core.hpp>
+
+struct AppRenderTargets {
+	vkcv::ImageHandle depthBuffer;
+	vkcv::ImageHandle colorBuffer;
+	vkcv::ImageHandle motionBuffer;
+};
+
+struct GraphicPassHandles {
+	vkcv::PipelineHandle        pipeline;
+	vkcv::PassHandle            renderPass;
+	vkcv::DescriptorSetHandle   descriptorSet;
+};
+
+struct ComputePassHandles {
+	vkcv::PipelineHandle        pipeline;
+	vkcv::DescriptorSetHandle   descriptorSet;
+};
+
+struct MeshResources {
+	vkcv::Mesh          mesh;
+	vkcv::BufferHandle  vertexBuffer;
+	vkcv::BufferHandle  indexBuffer;
+};
+
+// loads position, uv and normal of the first mesh in a scene
+bool loadMesh(vkcv::Core& core, const std::filesystem::path& path, MeshResources* outMesh);
+
+bool loadImage(vkcv::Core& core, const std::filesystem::path& path, vkcv::ImageHandle* outImage);
+
+bool loadGraphicPass(
+	vkcv::Core& core,
+	const std::filesystem::path vertexPath,
+	const std::filesystem::path fragmentPath,
+	const vkcv::PassConfig&     passConfig,
+	const vkcv::DepthTest       depthTest,
+	GraphicPassHandles*         outPassHandles);
+
+bool loadMeshPass  (vkcv::Core& core, GraphicPassHandles* outHandles);
+bool loadSkyPass   (vkcv::Core& core, GraphicPassHandles* outHandles);
+bool loadPrePass   (vkcv::Core& core, GraphicPassHandles* outHandles);
+bool loadSkyPrePass(vkcv::Core& core, GraphicPassHandles* outHandles);
+
+bool loadComputePass(vkcv::Core& core, const std::filesystem::path& path, ComputePassHandles* outComputePass);
+
+AppRenderTargets createRenderTargets(vkcv::Core& core, const uint32_t width, const uint32_t height);
\ No newline at end of file

projects/indirect_dispatch/src/MotionBlur.cpp

+#include "MotionBlur.hpp"
+#include "MotionBlurConfig.hpp"
+#include "MotionBlurSetup.hpp"
+#include <array>
+
+std::array<uint32_t, 3> computeFullscreenDispatchSize(
+	const uint32_t imageWidth,
+	const uint32_t imageHeight,
+	const uint32_t localGroupSize) {
+
+	// optimized divide and ceil
+	return std::array<uint32_t, 3>{
+		static_cast<uint32_t>(imageWidth  + (localGroupSize - 1)) / localGroupSize,
+		static_cast<uint32_t>(imageHeight + (localGroupSize - 1)) / localGroupSize,
+		static_cast<uint32_t>(1) };
+}
+
+bool MotionBlur::initialize(vkcv::Core* corePtr, const uint32_t targetWidth, const uint32_t targetHeight) {
+
+	if (!corePtr) {
+		vkcv_log(vkcv::LogLevel::ERROR, "MotionBlur got invalid corePtr")
+		return false;
+	}
+
+	m_core = corePtr;
+
+	if (!loadComputePass(*m_core, "resources/shaders/motionBlur.comp", &m_motionBlurPass))
+		return false;
+
+	if (!loadComputePass(*m_core, "resources/shaders/motionVectorMinMax.comp", &m_motionVectorMinMaxPass))
+		return false;
+
+	if (!loadComputePass(*m_core, "resources/shaders/motionVectorMinMaxNeighbourhood.comp", &m_motionVectorMinMaxNeighbourhoodPass))
+		return false;
+
+	if (!loadComputePass(*m_core, "resources/shaders/motionVectorVisualisation.comp", &m_motionVectorVisualisationPass))
+		return false;
+
+	if (!loadComputePass(*m_core, "resources/shaders/motionBlurColorCopy.comp", &m_colorCopyPass))
+		return false;
+
+	if (!loadComputePass(*m_core, "resources/shaders/motionBlurTileClassification.comp", &m_tileClassificationPass))
+		return false;
+
+	if (!loadComputePass(*m_core, "resources/shaders/motionBlurWorkTileReset.comp", &m_tileResetPass))
+		return false;
+
+	if (!loadComputePass(*m_core, "resources/shaders/motionBlurTileClassificationVis.comp", &m_tileVisualisationPass))
+		return false;
+
+	if (!loadComputePass(*m_core, "resources/shaders/motionBlurFastPath.comp", &m_motionBlurFastPathPass))
+		return false;
+
+	// work tile buffers and descriptors
+	const uint32_t workTileBufferSize = static_cast<uint32_t>(2 * sizeof(uint32_t)) * (3 +
+		((MotionBlurConfig::maxWidth + MotionBlurConfig::maxMotionTileSize - 1) / MotionBlurConfig::maxMotionTileSize) *
+		((MotionBlurConfig::maxHeight + MotionBlurConfig::maxMotionTileSize - 1) / MotionBlurConfig::maxMotionTileSize));
+
+	m_copyPathWorkTileBuffer = m_core->createBuffer<uint32_t>(
+		vkcv::BufferType::STORAGE, 
+		workTileBufferSize, 
+		vkcv::BufferMemoryType::DEVICE_LOCAL, 
+		true).getHandle();
+
+	m_fullPathWorkTileBuffer = m_core->createBuffer<uint32_t>(
+		vkcv::BufferType::STORAGE, 
+		workTileBufferSize, 
+		vkcv::BufferMemoryType::DEVICE_LOCAL, 
+		true).getHandle();
+
+	m_fastPathWorkTileBuffer = m_core->createBuffer<uint32_t>(
+		vkcv::BufferType::STORAGE,
+		workTileBufferSize,
+		vkcv::BufferMemoryType::DEVICE_LOCAL,
+		true).getHandle();
+
+	vkcv::DescriptorWrites tileResetDescriptorWrites;
+	tileResetDescriptorWrites.storageBufferWrites = {
+		vkcv::BufferDescriptorWrite(0, m_fullPathWorkTileBuffer),
+		vkcv::BufferDescriptorWrite(1, m_copyPathWorkTileBuffer),
+		vkcv::BufferDescriptorWrite(2, m_fastPathWorkTileBuffer) };
+
+	m_core->writeDescriptorSet(m_tileResetPass.descriptorSet, tileResetDescriptorWrites);
+
+
+	m_renderTargets = MotionBlurSetup::createRenderTargets(targetWidth, targetHeight, *m_core);
+
+	m_nearestSampler = m_core->createSampler(
+		vkcv::SamplerFilterType::NEAREST,
+		vkcv::SamplerFilterType::NEAREST,
+		vkcv::SamplerMipmapMode::NEAREST,
+		vkcv::SamplerAddressMode::CLAMP_TO_EDGE);
+	
+	return true;
+}
+
+void MotionBlur::setResolution(const uint32_t targetWidth, const uint32_t targetHeight) {
+	m_renderTargets = MotionBlurSetup::createRenderTargets(targetWidth, targetHeight, *m_core);
+}
+
+vkcv::ImageHandle MotionBlur::render(
+	const vkcv::CommandStreamHandle cmdStream,
+	const vkcv::ImageHandle         motionBufferFullRes,
+	const vkcv::ImageHandle         colorBuffer,
+	const vkcv::ImageHandle         depthBuffer,
+	const eMotionBlurMode           mode,
+	const float                     cameraNear,
+	const float                     cameraFar,
+	const float                     deltaTimeSeconds,
+	const float                     cameraShutterSpeedInverse,
+	const float                     motionTileOffsetLength,
+	const float                     fastPathThreshold) {
+
+	computeMotionTiles(cmdStream, motionBufferFullRes);
+
+	// work tile reset
+	const uint32_t dispatchSizeOne[3] = { 1, 1, 1 };
+
+	m_core->recordComputeDispatchToCmdStream(
+		cmdStream,
+		m_tileResetPass.pipeline,
+		dispatchSizeOne,
+		{ vkcv::DescriptorSetUsage(0, m_core->getDescriptorSet(m_tileResetPass.descriptorSet).vulkanHandle) },
+		vkcv::PushConstants(0));
+
+	m_core->recordBufferMemoryBarrier(cmdStream, m_fullPathWorkTileBuffer);
+	m_core->recordBufferMemoryBarrier(cmdStream, m_copyPathWorkTileBuffer);
+	m_core->recordBufferMemoryBarrier(cmdStream, m_fastPathWorkTileBuffer);
+
+	// work tile classification
+	vkcv::DescriptorWrites tileClassificationDescriptorWrites;
+	tileClassificationDescriptorWrites.sampledImageWrites = {
+		vkcv::SampledImageDescriptorWrite(0, m_renderTargets.motionMaxNeighbourhood),
+		vkcv::SampledImageDescriptorWrite(1, m_renderTargets.motionMinNeighbourhood) };
+	tileClassificationDescriptorWrites.samplerWrites = {
+		vkcv::SamplerDescriptorWrite(2, m_nearestSampler) };
+	tileClassificationDescriptorWrites.storageBufferWrites = {
+		vkcv::BufferDescriptorWrite(3, m_fullPathWorkTileBuffer),
+		vkcv::BufferDescriptorWrite(4, m_copyPathWorkTileBuffer),
+		vkcv::BufferDescriptorWrite(5, m_fastPathWorkTileBuffer) };
+
+	m_core->writeDescriptorSet(m_tileClassificationPass.descriptorSet, tileClassificationDescriptorWrites);
+
+	const auto tileClassificationDispatch = computeFullscreenDispatchSize(
+		m_core->getImageWidth(m_renderTargets.motionMaxNeighbourhood), 
+		m_core->getImageHeight(m_renderTargets.motionMaxNeighbourhood),
+		8);
+
+	struct ClassificationConstants {
+		uint32_t    width;
+		uint32_t    height;
+		float       fastPathThreshold;
+	};
+	ClassificationConstants classificationConstants;
+	classificationConstants.width               = m_core->getImageWidth(m_renderTargets.outputColor);
+	classificationConstants.height              = m_core->getImageHeight(m_renderTargets.outputColor);
+	classificationConstants.fastPathThreshold   = fastPathThreshold;
+
+	vkcv::PushConstants classificationPushConstants(sizeof(ClassificationConstants));
+    classificationPushConstants.appendDrawcall(classificationConstants);
+
+	m_core->prepareImageForSampling(cmdStream, m_renderTargets.motionMaxNeighbourhood);
+	m_core->prepareImageForSampling(cmdStream, m_renderTargets.motionMinNeighbourhood);
+
+	m_core->recordComputeDispatchToCmdStream(
+		cmdStream,
+		m_tileClassificationPass.pipeline,
+		tileClassificationDispatch.data(),
+		{ vkcv::DescriptorSetUsage(0, m_core->getDescriptorSet(m_tileClassificationPass.descriptorSet).vulkanHandle) },
+		classificationPushConstants);
+
+	m_core->recordBufferMemoryBarrier(cmdStream, m_fullPathWorkTileBuffer);
+	m_core->recordBufferMemoryBarrier(cmdStream, m_copyPathWorkTileBuffer);
+	m_core->recordBufferMemoryBarrier(cmdStream, m_fastPathWorkTileBuffer);
+
+	vkcv::DescriptorWrites motionBlurDescriptorWrites;
+	motionBlurDescriptorWrites.sampledImageWrites = {
+		vkcv::SampledImageDescriptorWrite(0, colorBuffer),
+		vkcv::SampledImageDescriptorWrite(1, depthBuffer),
+		vkcv::SampledImageDescriptorWrite(2, motionBufferFullRes),
+		vkcv::SampledImageDescriptorWrite(3, m_renderTargets.motionMaxNeighbourhood) };
+	motionBlurDescriptorWrites.samplerWrites = {
+		vkcv::SamplerDescriptorWrite(4, m_nearestSampler) };
+	motionBlurDescriptorWrites.storageImageWrites = {
+		vkcv::StorageImageDescriptorWrite(5, m_renderTargets.outputColor) };
+	motionBlurDescriptorWrites.storageBufferWrites = {
+		vkcv::BufferDescriptorWrite(6, m_fullPathWorkTileBuffer)};
+
+	m_core->writeDescriptorSet(m_motionBlurPass.descriptorSet, motionBlurDescriptorWrites);
+
+
+	vkcv::DescriptorWrites colorCopyDescriptorWrites;
+	colorCopyDescriptorWrites.sampledImageWrites = {
+		vkcv::SampledImageDescriptorWrite(0, colorBuffer) };
+	colorCopyDescriptorWrites.samplerWrites = {
+		vkcv::SamplerDescriptorWrite(1, m_nearestSampler) };
+	colorCopyDescriptorWrites.storageImageWrites = {
+		vkcv::StorageImageDescriptorWrite(2, m_renderTargets.outputColor) };
+	colorCopyDescriptorWrites.storageBufferWrites = {
+		vkcv::BufferDescriptorWrite(3, m_copyPathWorkTileBuffer) };
+
+	m_core->writeDescriptorSet(m_colorCopyPass.descriptorSet, colorCopyDescriptorWrites);
+
+
+	vkcv::DescriptorWrites fastPathDescriptorWrites;
+	fastPathDescriptorWrites.sampledImageWrites = {
+		vkcv::SampledImageDescriptorWrite(0, colorBuffer),
+		vkcv::SampledImageDescriptorWrite(1, m_renderTargets.motionMaxNeighbourhood) };
+	fastPathDescriptorWrites.samplerWrites = {
+		vkcv::SamplerDescriptorWrite(2, m_nearestSampler) };
+	fastPathDescriptorWrites.storageImageWrites = {
+		vkcv::StorageImageDescriptorWrite(3, m_renderTargets.outputColor) };
+	fastPathDescriptorWrites.storageBufferWrites = {
+		vkcv::BufferDescriptorWrite(4, m_fastPathWorkTileBuffer) };
+
+	m_core->writeDescriptorSet(m_motionBlurFastPathPass.descriptorSet, fastPathDescriptorWrites);
+
+	// must match layout in "motionBlur.comp"
+	struct MotionBlurConstantData {
+		float motionFactor;
+		float cameraNearPlane;
+		float cameraFarPlane;
+		float motionTileOffsetLength;
+	};
+	MotionBlurConstantData motionBlurConstantData;
+
+	const float deltaTimeMotionBlur = deltaTimeSeconds;
+
+	motionBlurConstantData.motionFactor             = 1 / (deltaTimeMotionBlur * cameraShutterSpeedInverse);
+	motionBlurConstantData.cameraNearPlane          = cameraNear;
+	motionBlurConstantData.cameraFarPlane           = cameraFar;
+	motionBlurConstantData.motionTileOffsetLength   = motionTileOffsetLength;
+
+	vkcv::PushConstants motionBlurPushConstants(sizeof(motionBlurConstantData));
+	motionBlurPushConstants.appendDrawcall(motionBlurConstantData);
+
+	struct FastPathConstants {
+		float motionFactor;
+	};
+	FastPathConstants fastPathConstants;
+	fastPathConstants.motionFactor = motionBlurConstantData.motionFactor;
+
+	vkcv::PushConstants fastPathPushConstants(sizeof(FastPathConstants));
+	fastPathPushConstants.appendDrawcall(fastPathConstants);
+
+	m_core->prepareImageForStorage(cmdStream, m_renderTargets.outputColor);
+	m_core->prepareImageForSampling(cmdStream, colorBuffer);
+	m_core->prepareImageForSampling(cmdStream, depthBuffer);
+	m_core->prepareImageForSampling(cmdStream, m_renderTargets.motionMaxNeighbourhood);
+
+	if (mode == eMotionBlurMode::Default) {
+		m_core->recordComputeIndirectDispatchToCmdStream(
+			cmdStream,
+			m_motionBlurPass.pipeline,
+			m_fullPathWorkTileBuffer,
+			0,
+			{ vkcv::DescriptorSetUsage(0, m_core->getDescriptorSet(m_motionBlurPass.descriptorSet).vulkanHandle) },
+			motionBlurPushConstants);
+
+		m_core->recordComputeIndirectDispatchToCmdStream(
+			cmdStream,
+			m_colorCopyPass.pipeline,
+			m_copyPathWorkTileBuffer,
+			0,
+			{ vkcv::DescriptorSetUsage(0, m_core->getDescriptorSet(m_colorCopyPass.descriptorSet).vulkanHandle) },
+			vkcv::PushConstants(0));
+
+		m_core->recordComputeIndirectDispatchToCmdStream(
+			cmdStream,
+			m_motionBlurFastPathPass.pipeline,
+			m_fastPathWorkTileBuffer,
+			0,
+			{ vkcv::DescriptorSetUsage(0, m_core->getDescriptorSet(m_motionBlurFastPathPass.descriptorSet).vulkanHandle) },
+			fastPathPushConstants);
+	}
+	else if(mode == eMotionBlurMode::Disabled) {
+		return colorBuffer;
+	}
+	else if (mode == eMotionBlurMode::TileVisualisation) {
+
+		vkcv::DescriptorWrites visualisationDescriptorWrites;
+		visualisationDescriptorWrites.sampledImageWrites = { 
+			vkcv::SampledImageDescriptorWrite(0, colorBuffer) };
+		visualisationDescriptorWrites.samplerWrites = {
+			vkcv::SamplerDescriptorWrite(1, m_nearestSampler) };
+		visualisationDescriptorWrites.storageImageWrites = {
+			vkcv::StorageImageDescriptorWrite(2, m_renderTargets.outputColor)};
+		visualisationDescriptorWrites.storageBufferWrites = {
+			vkcv::BufferDescriptorWrite(3, m_fullPathWorkTileBuffer),
+			vkcv::BufferDescriptorWrite(4, m_copyPathWorkTileBuffer),
+			vkcv::BufferDescriptorWrite(5, m_fastPathWorkTileBuffer) };
+
+		m_core->writeDescriptorSet(m_tileVisualisationPass.descriptorSet, visualisationDescriptorWrites);
+
+		const uint32_t tileCount = 
+			(m_core->getImageWidth(m_renderTargets.outputColor)  + MotionBlurConfig::maxMotionTileSize - 1) / MotionBlurConfig::maxMotionTileSize * 
+			(m_core->getImageHeight(m_renderTargets.outputColor) + MotionBlurConfig::maxMotionTileSize - 1) / MotionBlurConfig::maxMotionTileSize;
+
+		const uint32_t dispatchCounts[3] = {
+			tileCount,
+			1,
+			1 };
+
+		m_core->recordComputeDispatchToCmdStream(
+			cmdStream,
+			m_tileVisualisationPass.pipeline,
+			dispatchCounts,
+			{ vkcv::DescriptorSetUsage(0, m_core->getDescriptorSet(m_tileVisualisationPass.descriptorSet).vulkanHandle) },
+			vkcv::PushConstants(0));
+	}
+	else {
+		vkcv_log(vkcv::LogLevel::ERROR, "Unknown eMotionBlurMode enum option");
+		return colorBuffer;
+	}
+
+	return m_renderTargets.outputColor;
+}
+
+vkcv::ImageHandle MotionBlur::renderMotionVectorVisualisation(
+	const vkcv::CommandStreamHandle         cmdStream,
+	const vkcv::ImageHandle                 motionBuffer,
+	const eMotionVectorVisualisationMode    mode,
+	const float                             velocityRange) {
+
+	computeMotionTiles(cmdStream, motionBuffer);
+
+	vkcv::ImageHandle visualisationInput;
+	if (     mode == eMotionVectorVisualisationMode::FullResolution)
+		visualisationInput = motionBuffer;
+	else if (mode == eMotionVectorVisualisationMode::MaxTile)
+		visualisationInput = m_renderTargets.motionMax;
+	else if (mode == eMotionVectorVisualisationMode::MaxTileNeighbourhood)
+		visualisationInput = m_renderTargets.motionMaxNeighbourhood;
+	else if (mode == eMotionVectorVisualisationMode::MinTile)
+		visualisationInput = m_renderTargets.motionMin;
+	else if (mode == eMotionVectorVisualisationMode::MinTileNeighbourhood)
+		visualisationInput = m_renderTargets.motionMinNeighbourhood;
+	else if (mode == eMotionVectorVisualisationMode::None) {
+		vkcv_log(vkcv::LogLevel::ERROR, "renderMotionVectorVisualisation called with visualisation mode 'None'");
+		return motionBuffer;
+	}
+	else {
+		vkcv_log(vkcv::LogLevel::ERROR, "Unknown eDebugView enum value");
+		return motionBuffer;
+	}
+
+	vkcv::DescriptorWrites motionVectorVisualisationDescriptorWrites;
+	motionVectorVisualisationDescriptorWrites.sampledImageWrites = {
+		vkcv::SampledImageDescriptorWrite(0, visualisationInput) };
+	motionVectorVisualisationDescriptorWrites.samplerWrites = {
+		vkcv::SamplerDescriptorWrite(1, m_nearestSampler) };
+	motionVectorVisualisationDescriptorWrites.storageImageWrites = {
+		vkcv::StorageImageDescriptorWrite(2, m_renderTargets.outputColor) };
+
+	m_core->writeDescriptorSet(
+		m_motionVectorVisualisationPass.descriptorSet,
+		motionVectorVisualisationDescriptorWrites);
+
+	m_core->prepareImageForSampling(cmdStream, visualisationInput);
+	m_core->prepareImageForStorage(cmdStream, m_renderTargets.outputColor);
+
+	vkcv::PushConstants motionVectorVisualisationPushConstants(sizeof(float));
+	motionVectorVisualisationPushConstants.appendDrawcall(velocityRange);
+
+	const auto dispatchSizes = computeFullscreenDispatchSize(
+		m_core->getImageWidth(m_renderTargets.outputColor), 
+		m_core->getImageHeight(m_renderTargets.outputColor), 
+		8);
+
+	m_core->recordComputeDispatchToCmdStream(
+		cmdStream,
+		m_motionVectorVisualisationPass.pipeline,
+		dispatchSizes.data(),
+		{ vkcv::DescriptorSetUsage(0, m_core->getDescriptorSet(m_motionVectorVisualisationPass.descriptorSet).vulkanHandle) },
+		motionVectorVisualisationPushConstants);
+
+	return m_renderTargets.outputColor;
+}
+
+void MotionBlur::computeMotionTiles(
+	const vkcv::CommandStreamHandle cmdStream,
+	const vkcv::ImageHandle         motionBufferFullRes) {
+
+	// motion vector min max tiles
+	vkcv::DescriptorWrites motionVectorMaxTilesDescriptorWrites;
+	motionVectorMaxTilesDescriptorWrites.sampledImageWrites = {
+		vkcv::SampledImageDescriptorWrite(0, motionBufferFullRes) };
+	motionVectorMaxTilesDescriptorWrites.samplerWrites = {
+		vkcv::SamplerDescriptorWrite(1, m_nearestSampler) };
+	motionVectorMaxTilesDescriptorWrites.storageImageWrites = {
+		vkcv::StorageImageDescriptorWrite(2, m_renderTargets.motionMax),
+		vkcv::StorageImageDescriptorWrite(3, m_renderTargets.motionMin) };
+
+	m_core->writeDescriptorSet(m_motionVectorMinMaxPass.descriptorSet, motionVectorMaxTilesDescriptorWrites);
+
+	m_core->prepareImageForSampling(cmdStream, motionBufferFullRes);
+	m_core->prepareImageForStorage(cmdStream, m_renderTargets.motionMax);
+	m_core->prepareImageForStorage(cmdStream, m_renderTargets.motionMin);
+
+	const std::array<uint32_t, 3> motionTileDispatchCounts = computeFullscreenDispatchSize(
+		m_core->getImageWidth( m_renderTargets.motionMax),
+		m_core->getImageHeight(m_renderTargets.motionMax),
+		8);
+
+	m_core->recordComputeDispatchToCmdStream(
+		cmdStream,
+		m_motionVectorMinMaxPass.pipeline,
+		motionTileDispatchCounts.data(),
+		{ vkcv::DescriptorSetUsage(0, m_core->getDescriptorSet(m_motionVectorMinMaxPass.descriptorSet).vulkanHandle) },
+		vkcv::PushConstants(0));
+
+	// motion vector min max neighbourhood
+	vkcv::DescriptorWrites motionVectorMaxNeighbourhoodDescriptorWrites;
+	motionVectorMaxNeighbourhoodDescriptorWrites.sampledImageWrites = {
+		vkcv::SampledImageDescriptorWrite(0, m_renderTargets.motionMax),
+		vkcv::SampledImageDescriptorWrite(1, m_renderTargets.motionMin) };
+	motionVectorMaxNeighbourhoodDescriptorWrites.samplerWrites = {
+		vkcv::SamplerDescriptorWrite(2, m_nearestSampler) };
+	motionVectorMaxNeighbourhoodDescriptorWrites.storageImageWrites = {
+		vkcv::StorageImageDescriptorWrite(3, m_renderTargets.motionMaxNeighbourhood),
+		vkcv::StorageImageDescriptorWrite(4, m_renderTargets.motionMinNeighbourhood) };
+
+	m_core->writeDescriptorSet(m_motionVectorMinMaxNeighbourhoodPass.descriptorSet, motionVectorMaxNeighbourhoodDescriptorWrites);
+
+	m_core->prepareImageForSampling(cmdStream, m_renderTargets.motionMax);
+	m_core->prepareImageForSampling(cmdStream, m_renderTargets.motionMin);
+
+	m_core->prepareImageForStorage(cmdStream, m_renderTargets.motionMaxNeighbourhood);
+	m_core->prepareImageForStorage(cmdStream, m_renderTargets.motionMinNeighbourhood);
+
+	m_core->recordComputeDispatchToCmdStream(
+		cmdStream,
+		m_motionVectorMinMaxNeighbourhoodPass.pipeline,
+		motionTileDispatchCounts.data(),
+		{ vkcv::DescriptorSetUsage(0, m_core->getDescriptorSet(m_motionVectorMinMaxNeighbourhoodPass.descriptorSet).vulkanHandle) },
+		vkcv::PushConstants(0));
+}
\ No newline at end of file

projects/indirect_dispatch/src/MotionBlur.hpp

+#pragma once
+#include <vkcv/Core.hpp>
+#include "AppSetup.hpp"
+#include "MotionBlurSetup.hpp"
+
+// selection for motion blur input and visualisation
+enum class eMotionVectorVisualisationMode : int {
+	None                    = 0,
+	FullResolution          = 1,
+	MaxTile                 = 2,
+	MaxTileNeighbourhood    = 3,
+	MinTile                 = 4,
+	MinTileNeighbourhood    = 5,
+	OptionCount             = 6 };
+
+static const char* MotionVectorVisualisationModeLabels[6] = {
+	"None",
+	"Full resolution",
+	"Max tile",
+	"Tile neighbourhood max",
+	"Min Tile",
+	"Tile neighbourhood min"};
+
+enum class eMotionBlurMode : int {
+	Default             = 0,
+	Disabled            = 1,
+	TileVisualisation   = 2,
+	OptionCount         = 3 };
+
+static const char* MotionBlurModeLabels[3] = {
+	"Default",
+	"Disabled",
+	"Tile visualisation" };
+
+class MotionBlur {
+public:
+
+	bool initialize(vkcv::Core* corePtr, const uint32_t targetWidth, const uint32_t targetHeight);
+	void setResolution(const uint32_t targetWidth, const uint32_t targetHeight);
+
+	vkcv::ImageHandle render(
+		const vkcv::CommandStreamHandle cmdStream,
+		const vkcv::ImageHandle         motionBufferFullRes,
+		const vkcv::ImageHandle         colorBuffer,
+		const vkcv::ImageHandle         depthBuffer,
+		const eMotionBlurMode           mode,
+		const float                     cameraNear,
+		const float                     cameraFar,
+		const float                     deltaTimeSeconds,
+		const float                     cameraShutterSpeedInverse,
+		const float                     motionTileOffsetLength,
+		const float                     fastPathThreshold);
+
+	vkcv::ImageHandle renderMotionVectorVisualisation(
+		const vkcv::CommandStreamHandle         cmdStream,
+		const vkcv::ImageHandle                 motionBuffer,
+		const eMotionVectorVisualisationMode    mode,
+		const float                             velocityRange);
+
+private:
+	// computes max per tile and neighbourhood tile max
+	void computeMotionTiles(
+		const vkcv::CommandStreamHandle cmdStream,
+		const vkcv::ImageHandle         motionBufferFullRes);
+
+	vkcv::Core* m_core;
+
+	MotionBlurRenderTargets m_renderTargets;
+	vkcv::SamplerHandle     m_nearestSampler;
+
+	ComputePassHandles m_motionBlurPass;
+	ComputePassHandles m_motionVectorMinMaxPass;
+	ComputePassHandles m_motionVectorMinMaxNeighbourhoodPass;
+	ComputePassHandles m_motionVectorVisualisationPass;
+	ComputePassHandles m_colorCopyPass;
+	ComputePassHandles m_tileClassificationPass;
+	ComputePassHandles m_tileResetPass;
+	ComputePassHandles m_tileVisualisationPass;
+	ComputePassHandles m_motionBlurFastPathPass;
+
+	vkcv::BufferHandle m_fullPathWorkTileBuffer;
+	vkcv::BufferHandle m_copyPathWorkTileBuffer;
+	vkcv::BufferHandle m_fastPathWorkTileBuffer;
+};
\ No newline at end of file

projects/indirect_dispatch/src/MotionBlurConfig.hpp

+#pragma once
+#include "vulkan/vulkan.hpp"
+
+namespace MotionBlurConfig {
+	const vk::Format    motionVectorTileFormat  = vk::Format::eR16G16Sfloat;
+	const vk::Format    outputColorFormat       = vk::Format::eB10G11R11UfloatPack32;
+	const uint32_t      maxMotionTileSize       = 16;	// must match "motionTileSize" in motionBlurConfig.inc
+	const uint32_t      maxWidth                = 3840;
+	const uint32_t      maxHeight               = 2160;
+}
\ No newline at end of file

projects/indirect_dispatch/src/MotionBlurSetup.cpp

+#include "MotionBlurSetup.hpp"
+#include "MotionBlurConfig.hpp"
+
+namespace MotionBlurSetup {
+
+MotionBlurRenderTargets createRenderTargets(const uint32_t width, const uint32_t height, vkcv::Core& core) {
+
+	MotionBlurRenderTargets targets;
+
+	// divide and ceil to int
+	const uint32_t motionMaxWidth  = (width  + (MotionBlurConfig::maxMotionTileSize - 1)) / MotionBlurConfig::maxMotionTileSize;
+	const uint32_t motionMaxheight = (height + (MotionBlurConfig::maxMotionTileSize - 1)) / MotionBlurConfig::maxMotionTileSize;
+
+	targets.motionMax = core.createImage(
+		MotionBlurConfig::motionVectorTileFormat,
+		motionMaxWidth,
+		motionMaxheight,
+		1,
+		false,
+		true).getHandle();
+
+	targets.motionMaxNeighbourhood = core.createImage(
+		MotionBlurConfig::motionVectorTileFormat,
+		motionMaxWidth,
+		motionMaxheight,
+		1,
+		false,
+		true).getHandle();
+
+	targets.motionMin = core.createImage(
+		MotionBlurConfig::motionVectorTileFormat,
+		motionMaxWidth,
+		motionMaxheight,
+		1,
+		false,
+		true).getHandle();
+
+	targets.motionMinNeighbourhood = core.createImage(
+		MotionBlurConfig::motionVectorTileFormat,
+		motionMaxWidth,
+		motionMaxheight,
+		1,
+		false,
+		true).getHandle();
+
+	targets.outputColor = core.createImage(
+		MotionBlurConfig::outputColorFormat,
+		width,
+		height,
+		1,
+		false,
+		true).getHandle();
+
+	return targets;
+}
+
+}	// namespace MotionBlurSetup
\ No newline at end of file

projects/indirect_dispatch/src/MotionBlurSetup.hpp

+#pragma once
+#include <vkcv/Core.hpp>
+
+struct MotionBlurRenderTargets {
+	vkcv::ImageHandle outputColor;
+	vkcv::ImageHandle motionMax;
+	vkcv::ImageHandle motionMaxNeighbourhood;
+	vkcv::ImageHandle motionMin;
+	vkcv::ImageHandle motionMinNeighbourhood;
+};
+
+namespace MotionBlurSetup {
+	MotionBlurRenderTargets createRenderTargets(const uint32_t width, const uint32_t height, vkcv::Core& core);
+}
\ No newline at end of file

projects/indirect_dispatch/src/main.cpp

+#include "App.hpp"
+
+int main(int argc, const char** argv) {
+
+	App app;
+	if (!app.initialize()) {
+		std::cerr << "Application initialization failed, exiting" << std::endl;
+		return 1;
+	}
+	app.run();
+
+	return 0;
+}

projects/mesh_shader/.gitignore

+mesh_shader

projects/bloom/CMakeLists.txt → projects/mesh_shader/CMakeLists.txt

 cmake_minimum_required(VERSION 3.16)
-project(bloom)
+project(mesh_shader)
 
 # setting c++ standard for the project
 set(CMAKE_CXX_STANDARD 17)
@@ -9,24 +9,22 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 
 # adding source files to the project
-add_executable(bloom src/main.cpp)
+add_executable(mesh_shader src/main.cpp)
 
-target_sources(bloom PRIVATE
-		src/BloomAndFlares.cpp
-		src/BloomAndFlares.hpp)
+target_sources(mesh_shader PRIVATE)
 
 # this should fix the execution path to load local files from the project (for MSVC)
 if(MSVC)
-	set_target_properties(bloom PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
-	set_target_properties(bloom PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
-    
-    # in addition to setting the output directory, the working directory has to be set
+	set_target_properties(mesh_shader PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+	set_target_properties(mesh_shader 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(bloom PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+	set_target_properties(mesh_shader PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 endif()
 
 # including headers of dependencies and the VkCV framework
-target_include_directories(bloom SYSTEM BEFORE PRIVATE ${vkcv_include} ${vkcv_includes} ${vkcv_asset_loader_include} ${vkcv_camera_include} ${vkcv_shader_compiler_include})
+target_include_directories(mesh_shader SYSTEM BEFORE PRIVATE ${vkcv_include} ${vkcv_includes} ${vkcv_testing_include} ${vkcv_camera_include} ${vkcv_meshlet_include} ${vkcv_shader_compiler_include} ${vkcv_gui_include})
 
 # linking with libraries from all dependencies and the VkCV framework
-target_link_libraries(bloom vkcv ${vkcv_libraries} vkcv_asset_loader ${vkcv_asset_loader_libraries} vkcv_camera vkcv_shader_compiler)
+target_link_libraries(mesh_shader vkcv ${vkcv_libraries} vkcv_asset_loader ${vkcv_asset_loader_libraries} vkcv_testing vkcv_camera vkcv_meshlet vkcv_shader_compiler vkcv_gui)
\ No newline at end of file

projects/mesh_shader/resources/shaders/common.inc

+struct ObjectMatrices{
+    mat4 model;
+    mat4 mvp;
+};
\ No newline at end of file

projects/mesh_shader/resources/shaders/meshlet.inc

+struct Meshlet{
+    uint    vertexOffset;
+    uint    vertexCount;
+    uint    indexOffset;
+    uint    indexCount;
+    vec3    meanPosition;
+    float   boundingSphereRadius;
+};
\ No newline at end of file

projects/mesh_shader/resources/shaders/shader.frag

+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in  vec3 passNormal;
+layout(location = 1) in  flat uint passTaskIndex;
+layout(location = 0) out vec3 outColor;
+
+uint lowbias32(uint x)
+{
+    x ^= x >> 16;
+    x *= 0x7feb352dU;
+    x ^= x >> 15;
+    x *= 0x846ca68bU;
+    x ^= x >> 16;
+    return x;
+}
+
+float hashToFloat(uint hash){
+    return (hash % 255) / 255.f;
+}
+
+vec3 colorFromIndex(uint i){
+    return vec3(
+        hashToFloat(lowbias32(i+0)),
+        hashToFloat(lowbias32(i+1)),
+        hashToFloat(lowbias32(i+2)));
+}
+
+void main() {
+	outColor = normalize(passNormal) * 0.5 + 0.5;
+    outColor = colorFromIndex(passTaskIndex);
+}
\ No newline at end of file

projects/mesh_shader/resources/shaders/shader.mesh

+#version 460
+#extension GL_ARB_separate_shader_objects   : enable
+#extension GL_GOOGLE_include_directive      : enable
+#extension GL_NV_mesh_shader                : require
+
+#include "meshlet.inc"
+
+layout(local_size_x=32) in;
+
+layout(triangles) out;
+layout(max_vertices=64, max_primitives=126) out;
+
+layout(location = 0) out vec3 passNormal[];
+layout(location = 1) out uint passTaskIndex[];
+
+struct Vertex
+{
+    vec3 position;  float padding0;
+    vec3 normal;    float padding1;
+};
+
+layout(std430, binding = 0) readonly buffer vertexBuffer
+{
+    Vertex vertices[];
+};
+
+layout(std430, binding = 1) readonly buffer indexBuffer
+{
+    uint localIndices[]; // breaks for 16 bit indices
+};
+
+layout(std430, binding = 2) readonly buffer meshletBuffer
+{
+    Meshlet meshlets[];
+};
+
+taskNV in Task {
+  uint meshletIndices[32];
+  mat4 mvp;
+} IN;
+
+void main()	{
+    
+    uint meshletIndex = IN.meshletIndices[gl_WorkGroupID.x];
+    Meshlet meshlet = meshlets[meshletIndex];
+    
+    // set vertices
+    for(uint i = 0; i < 2; i++){
+    
+        uint workIndex = gl_LocalInvocationID.x + 32 * i;
+        if(workIndex >= meshlet.vertexCount){
+            break;
+        }
+    
+        uint vertexIndex    = meshlet.vertexOffset + workIndex;
+        Vertex vertex       = vertices[vertexIndex];
+    
+        gl_MeshVerticesNV[workIndex].gl_Position    = IN.mvp * vec4(vertex.position, 1);
+        passNormal[workIndex]                       = vertex.normal;
+        passTaskIndex[workIndex]                    = meshletIndex;
+    }
+    
+    // set local indices
+    for(uint i = 0; i < 12; i++){
+    
+        uint workIndex = gl_LocalInvocationID.x + i * 32;
+        if(workIndex >= meshlet.indexCount){
+            break;
+        }    
+        
+        uint indexBufferIndex               = meshlet.indexOffset + workIndex;
+        gl_PrimitiveIndicesNV[workIndex]    = localIndices[indexBufferIndex];
+    }
+    
+    if(gl_LocalInvocationID.x == 0){
+        gl_PrimitiveCountNV = meshlet.indexCount / 3;
+    }
+}
\ No newline at end of file

projects/mesh_shader/resources/shaders/shader.task

+#version 460
+#extension GL_ARB_separate_shader_objects   : enable
+#extension GL_NV_mesh_shader                : require
+#extension GL_GOOGLE_include_directive      : enable
+
+#include "meshlet.inc"
+#include "common.inc"
+
+layout(local_size_x=32) in;
+
+taskNV out Task {
+  uint meshletIndices[32];
+  mat4 mvp;
+} OUT;
+
+layout( push_constant ) uniform constants{
+    uint matrixIndex;
+    uint meshletCount;
+};
+
+// TODO: reuse mesh stage binding at location 2 after required fix in framework
+layout(std430, binding = 5) readonly buffer meshletBuffer
+{
+    Meshlet meshlets[];
+};
+
+struct Plane{
+    vec3    pointOnPlane;
+    float   padding0;
+    vec3    normal;
+    float   padding1;
+};
+
+layout(set=0, binding=3, std140) uniform cameraPlaneBuffer{
+    Plane cameraPlanes[6];
+};
+
+layout(std430, binding = 4) readonly buffer matrixBuffer
+{
+    ObjectMatrices objectMatrices[];
+};
+
+shared uint taskCount;
+
+bool isSphereInsideFrustum(vec3 spherePos, float sphereRadius, Plane cameraPlanes[6]){
+    bool isInside = true;
+    for(int i = 0; i < 6; i++){
+        Plane p     = cameraPlanes[i];
+        isInside    = isInside && dot(p.normal, spherePos - p.pointOnPlane) - sphereRadius < 0;
+    }
+    return isInside;
+}
+
+void main() {
+
+    if(gl_LocalInvocationID.x >= meshletCount){
+        return;
+    }
+    
+    uint meshletIndex   = gl_GlobalInvocationID.x;
+    Meshlet meshlet     = meshlets[meshletIndex]; 
+    
+    if(gl_LocalInvocationID.x == 0){
+        taskCount = 0;
+    }
+    
+    // TODO: scaling support
+    vec3 meshletPositionWorld = (vec4(meshlet.meanPosition, 1) * objectMatrices[matrixIndex].model).xyz;
+    if(isSphereInsideFrustum(meshletPositionWorld, meshlet.boundingSphereRadius, cameraPlanes)){
+        uint outIndex = atomicAdd(taskCount, 1);
+        OUT.meshletIndices[outIndex] = gl_GlobalInvocationID.x;
+    }
+
+    if(gl_LocalInvocationID.x == 0){
+        gl_TaskCountNV              = taskCount;
+        OUT.mvp = objectMatrices[matrixIndex].mvp;
+    }
+}
\ No newline at end of file