MatthiasQuintern/vulkan-project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

using VulkanAllocator and public interface of instance

Browse Source
This commit is contained in:
matthias@arch 2022-10-21 22:00:34 +02:00
parent 5d254bc513
commit e8f736d27f
12 changed files with 279 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/renderer/renderer.cpp
View File

@ -6,10 +6,7 @@ namespace gz::vk {
void Renderer::cleanup_(){ void Renderer::cleanup_(){
vk.destroyCommandBuffers(commandBuffers); vk.destroyCommandBuffers(commandBuffers);
vkDestroyBuffer(vk.device, indexBuffer, nullptr); vk.destroyBuffer(indexBuffer, indexBufferMemory);
vkFreeMemory(vk.device, indexBufferMemory, nullptr); vk.destroyBuffer(vertexBuffer, vertexBufferMemory);
vkDestroyBuffer(vk.device, vertexBuffer, nullptr);
vkFreeMemory(vk.device, vertexBufferMemory, nullptr);
} }
} }

12
src/renderer/renderer.hpp
View File

@ -3,6 +3,7 @@
// includes for child classes // includes for child classes
#include "texture_manager.hpp" #include "texture_manager.hpp"
#include "vertex.hpp" #include "vertex.hpp"
#include "vulkan_allocator.hpp"
#include <gz-util/log.hpp> #include <gz-util/log.hpp>
@ -19,6 +20,13 @@ namespace gz::vk {
public: public:
Renderer(VulkanInstance& instance, TextureManager& textureManager) : vk(instance), textureManager(textureManager) {}; Renderer(VulkanInstance& instance, TextureManager& textureManager) : vk(instance), textureManager(textureManager) {};
protected: protected:
/**
* @brief Cleanup vulkan resources held by this class
* @details
* - destroy commandBuffers
* - destroy(free) indexBuffer(Memory)
* - destroy(free) vertexBuffer(Memory)
*/
void cleanup_(); void cleanup_();
VulkanInstance& vk; VulkanInstance& vk;
TextureManager& textureManager; TextureManager& textureManager;
@ -26,10 +34,10 @@ namespace gz::vk {
std::vector<VkCommandBuffer> commandBuffers; std::vector<VkCommandBuffer> commandBuffers;
/// On device local memory /// On device local memory
VkBuffer vertexBuffer; VkBuffer vertexBuffer;
VkDeviceMemory vertexBufferMemory; MemoryInfo vertexBufferMemory;
VkDeviceSize vertexBufferSize; VkDeviceSize vertexBufferSize;
VkBuffer indexBuffer; VkBuffer indexBuffer;
VkDeviceMemory indexBufferMemory; MemoryInfo indexBufferMemory;
VkDeviceSize indexBufferSize; VkDeviceSize indexBufferSize;
}; // class RendererBase }; // class RendererBase
} // namespace gz::vk } // namespace gz::vk

71
src/renderer/renderer2D.cpp
View File

@ -2,6 +2,7 @@
#include "exceptions.hpp" #include "exceptions.hpp"
#include "vk_enum_string.h" #include "vk_enum_string.h"
#include "vulkan_allocator.hpp"
#include "vulkan_instance.hpp" #include "vulkan_instance.hpp"
#include "texture_manager.hpp" #include "texture_manager.hpp"
@ -62,16 +63,16 @@ namespace gz::vk {
void Renderer2D::cleanupSwapChainDependantResources() { void Renderer2D::cleanupSwapChainDependantResources() {
// destroy pipelines // destroy pipelines
pipelines.destroy(vk.device); pipelines.destroy(vk.getDevice());
vk.destroyFramebuffers(framebuffers); vk.destroyFramebuffers(framebuffers);
for (size_t i = 0; i < images.size(); i++) { for (size_t i = 0; i < images.size(); i++) {
vkDestroyImageView(vk.device, imageViews[i], nullptr); vkDestroyImageView(vk.getDevice(), imageViews[i], nullptr);
vkDestroyImage(vk.device, images[i], nullptr); vkDestroyImage(vk.getDevice(), images[i], nullptr);
vkFreeMemory(vk.device, imageMemory[i], nullptr); vkFreeMemory(vk.getDevice(), imageMemory[i], nullptr);
} }
vkDestroyRenderPass(vk.device, renderPass, nullptr); vkDestroyRenderPass(vk.getDevice(), renderPass, nullptr);
} }
@ -87,13 +88,13 @@ namespace gz::vk {
// IMAGES // IMAGES
// //
void Renderer2D::createImages() { void Renderer2D::createImages() {
images.resize(vk.scImages.size()); images.resize(vk.getScImages().size());
imageMemory.resize(vk.scImages.size()); imageMemory.resize(vk.getScImages().size());
imageViews.resize(vk.scImages.size()); imageViews.resize(vk.getScImages().size());
VkImageUsageFlags usage= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; VkImageUsageFlags usage= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
for (size_t i = 0; i < images.size(); i++) { for (size_t i = 0; i < images.size(); i++) {
vk.createImage(vk.scExtent.width, vk.scExtent.height, vk.scImageFormat, VK_IMAGE_TILING_OPTIMAL, usage, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, images[i], imageMemory[i]); vk.createImage(vk.getScExtent().width, vk.getScExtent().height, vk.getScImageFormat(), VK_IMAGE_TILING_OPTIMAL, usage, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, images[i], imageMemory[i]);
vk.createImageView(vk.scImageFormat, images[i], imageViews[i], VK_IMAGE_ASPECT_COLOR_BIT); vk.createImageView(vk.getScImageFormat(), images[i], imageViews[i], VK_IMAGE_ASPECT_COLOR_BIT);
} }
} }
@ -103,7 +104,7 @@ namespace gz::vk {
void Renderer2D::createRenderPass() { void Renderer2D::createRenderPass() {
VkAttachmentDescription2 colorBlendAttachment{}; VkAttachmentDescription2 colorBlendAttachment{};
colorBlendAttachment.sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2; colorBlendAttachment.sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
colorBlendAttachment.format = vk.scImageFormat; colorBlendAttachment.format = vk.getScImageFormat();
colorBlendAttachment.samples = VK_SAMPLE_COUNT_1_BIT; colorBlendAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorBlendAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; colorBlendAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorBlendAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; colorBlendAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
@ -149,14 +150,14 @@ namespace gz::vk {
// dependecy for the image layout transition to transfer dst // dependecy for the image layout transition to transfer dst
VkSubpassDependency2 layoutTransitionSD{}; VkSubpassDependency2 layoutTransitionSD{};
colorAttachmentSD.sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; layoutTransitionSD.sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2;
colorAttachmentSD.srcSubpass = 0; layoutTransitionSD.srcSubpass = 0;
colorAttachmentSD.dstSubpass = VK_SUBPASS_EXTERNAL; layoutTransitionSD.dstSubpass = VK_SUBPASS_EXTERNAL;
colorAttachmentSD.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT; layoutTransitionSD.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
colorAttachmentSD.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT; layoutTransitionSD.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
colorAttachmentSD.dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT; layoutTransitionSD.dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
colorAttachmentSD.dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT; layoutTransitionSD.dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT;
colorAttachmentSD.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; layoutTransitionSD.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
/* VkSubpassDependency dependency{}; */ /* VkSubpassDependency dependency{}; */
/* dependency.srcSubpass = VK_SUBPASS_EXTERNAL; */ /* dependency.srcSubpass = VK_SUBPASS_EXTERNAL; */
/* dependency.dstSubpass = 0; */ /* dependency.dstSubpass = 0; */
@ -180,7 +181,7 @@ namespace gz::vk {
/* renderPassCI.pDependencies = nullptr; */ /* renderPassCI.pDependencies = nullptr; */
/* renderPassCI.correlatedViewMaskCount = 0; */ /* renderPassCI.correlatedViewMaskCount = 0; */
/* renderPassCI.pCorrelatedViewMasks = nullptr; */ /* renderPassCI.pCorrelatedViewMasks = nullptr; */
VkResult result = vkCreateRenderPass2(vk.device, &renderPassCI, nullptr, &renderPass); VkResult result = vkCreateRenderPass2(vk.getDevice(), &renderPassCI, nullptr, &renderPass);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
throw getVkException(result, "Could not create render pass", "Renderer2D::createRenderPass"); throw getVkException(result, "Could not create render pass", "Renderer2D::createRenderPass");
} }
@ -207,7 +208,7 @@ namespace gz::vk {
renderPassBI.renderPass = renderPass; renderPassBI.renderPass = renderPass;
renderPassBI.framebuffer = framebuffers[imageIndex]; renderPassBI.framebuffer = framebuffers[imageIndex];
renderPassBI.renderArea.offset = { 0, 0 }; renderPassBI.renderArea.offset = { 0, 0 };
renderPassBI.renderArea.extent = vk.scExtent; renderPassBI.renderArea.extent = vk.getScExtent();
// clear // clear
std::array<VkClearValue, 1> clearValues{}; std::array<VkClearValue, 1> clearValues{};
clearValues[0].color = {{1.0f, 0.0f, 0.0f, 1.0f}}; clearValues[0].color = {{1.0f, 0.0f, 0.0f, 1.0f}};
@ -237,7 +238,7 @@ namespace gz::vk {
vkCmdDrawIndexed(commandBuffers[currentFrame], static_cast<uint32_t>(shapesIndicesCount), instanceCount, firstIndex, NO_OFFSET, firstInstance); vkCmdDrawIndexed(commandBuffers[currentFrame], static_cast<uint32_t>(shapesIndicesCount), instanceCount, firstIndex, NO_OFFSET, firstInstance);
vkCmdEndRenderPass(commandBuffers[currentFrame]); vkCmdEndRenderPass(commandBuffers[currentFrame]);
vk.copyImageToImage(commandBuffers[currentFrame], images[imageIndex], vk.scImages[imageIndex], vk.scExtent); vk.copyImageToImage(commandBuffers[currentFrame], images[imageIndex], vk.getScImages()[imageIndex], vk.getScExtent());
result = vkEndCommandBuffer(commandBuffers[currentFrame]); result = vkEndCommandBuffer(commandBuffers[currentFrame]);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
rLog.error("Failed to record 2D - command buffer", "VkResult:", STR_VK_RESULT(result)); rLog.error("Failed to record 2D - command buffer", "VkResult:", STR_VK_RESULT(result));
@ -255,12 +256,12 @@ namespace gz::vk {
// create staging buffer // create staging buffer
VkBuffer stagingBuffer; VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory; MemoryInfo stagingBufferMemory;
vk.createBuffer(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory); vk.createBuffer(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);
// fill staging buffer // fill staging buffer
void* data; void* data;
vkMapMemory(vk.device, stagingBufferMemory, NO_OFFSET, vertexBufferSize, NO_FLAGS, &data); vkMapMemory(vk.getDevice(), stagingBufferMemory.memory, stagingBufferMemory.offset, vertexBufferSize, NO_FLAGS, &data);
Vertex2D* vdata = reinterpret_cast<Vertex2D*>(data); Vertex2D* vdata = reinterpret_cast<Vertex2D*>(data);
size_t offset = 0; size_t offset = 0;
for (auto it = shapes.begin(); it != shapes.end(); it++) { for (auto it = shapes.begin(); it != shapes.end(); it++) {
@ -268,11 +269,10 @@ namespace gz::vk {
memcpy(vdata+offset, it->getVertices().data(), it->getVertices().size() * sizeof(Vertex2D)); memcpy(vdata+offset, it->getVertices().data(), it->getVertices().size() * sizeof(Vertex2D));
offset += it->getVertices().size(); offset += it->getVertices().size();
} }
vkUnmapMemory(vk.device, stagingBufferMemory); vkUnmapMemory(vk.getDevice(), stagingBufferMemory.memory);
// fill vertex buffer // fill vertex buffer
vk.copyBuffer(stagingBuffer, vertexBuffer, vertexBufferSize); vk.copyBuffer(stagingBuffer, vertexBuffer, vertexBufferSize);
vkDestroyBuffer(vk.device, stagingBuffer, nullptr); vk.destroyBuffer(stagingBuffer, stagingBufferMemory);
vkFreeMemory(vk.device, stagingBufferMemory, nullptr);
} }
void Renderer2D::fillIndexBufferWithShapes() { void Renderer2D::fillIndexBufferWithShapes() {
rLog("fillIndexBufferWithShapes"); rLog("fillIndexBufferWithShapes");
@ -282,12 +282,12 @@ namespace gz::vk {
// create staging buffer // create staging buffer
VkBuffer stagingBuffer; VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory; MemoryInfo stagingBufferMemory;
vk.createBuffer(indexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory); vk.createBuffer(indexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);
// fill staging buffer // fill staging buffer
void* data; void* data;
vkMapMemory(vk.device, stagingBufferMemory, NO_OFFSET, indexBufferSize, NO_FLAGS, &data); vkMapMemory(vk.getDevice(), stagingBufferMemory.memory, stagingBufferMemory.offset, indexBufferSize, NO_FLAGS, &data);
uint32_t* idata = reinterpret_cast<uint32_t*>(data); uint32_t* idata = reinterpret_cast<uint32_t*>(data);
size_t offset = 0; size_t offset = 0;
for (auto it = shapes.begin(); it != shapes.end(); it++) { for (auto it = shapes.begin(); it != shapes.end(); it++) {
@ -296,12 +296,11 @@ namespace gz::vk {
offset += it->getIndices().size(); offset += it->getIndices().size();
} }
rLog("fillIndexBufferWithShapes: indices count:", shapesIndicesCount); rLog("fillIndexBufferWithShapes: indices count:", shapesIndicesCount);
vkUnmapMemory(vk.device, stagingBufferMemory); vkUnmapMemory(vk.getDevice(), stagingBufferMemory.memory);
// fill index buffer // fill index buffer
vk.copyBuffer(stagingBuffer, indexBuffer, indexBufferSize); vk.copyBuffer(stagingBuffer, indexBuffer, indexBufferSize);
vkDestroyBuffer(vk.device, stagingBuffer, nullptr); vk.destroyBuffer(stagingBuffer, stagingBufferMemory);
vkFreeMemory(vk.device, stagingBufferMemory, nullptr);
} }
@ -309,7 +308,7 @@ namespace gz::vk {
void Renderer2D::drawShape(Shape* shape) { void Renderer2D::drawShape(Shape* shape) {
// make indices valid // make indices valid
shape->setIndexOffset(shapesVerticesCount); shape->setIndexOffset(shapesVerticesCount);
shape->normalizeVertices(vk.scExtent.width, vk.scExtent.height); shape->normalizeVertices(vk.getScExtent().width, vk.getScExtent().height);
shape->setTextureCoordinates(textureManager); shape->setTextureCoordinates(textureManager);
// object slicing here, need to call virtual setTextureCoordinates before this! // object slicing here, need to call virtual setTextureCoordinates before this!
shapes.push_back(*shape); shapes.push_back(*shape);
@ -319,9 +318,9 @@ namespace gz::vk {
void Renderer2D::drawFrame(uint32_t imageIndex) { void Renderer2D::drawFrame(uint32_t imageIndex) {
vkResetCommandBuffer(commandBuffers[vk.currentFrame], NO_FLAGS); vkResetCommandBuffer(commandBuffers[vk.getCurrentFrame()], NO_FLAGS);
/* recordCommandBuffer(imageIndex, vk.currentFrame); */ /* recordCommandBuffer(imageIndex, vk.getCurrentFrame()); */
recordCommandBuffer(imageIndex, vk.currentFrame); recordCommandBuffer(imageIndex, vk.getCurrentFrame());
} }

8
src/renderer/renderer2D.hpp
View File

@ -80,7 +80,7 @@ namespace gz::vk {
* @details * @details
* Attachments: * Attachments:
* - color blend: * - color blend:
* - loadOp = VK_ATTACHMENT_LOAD_OP_LOAD (not clear!) * - loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR
* - storeOp = VK_ATTACHMENT_STORE_OP_STORE * - storeOp = VK_ATTACHMENT_STORE_OP_STORE
* - initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL * - initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
* - finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL * - finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
@ -104,7 +104,7 @@ namespace gz::vk {
*/ */
/// @{ /// @{
/** /**
* @brief Cleans up resources that were initialized by initSwapChainDependantResources * @brief Cleans up resources that were initialized by initSwapChainDependantResources()
*/ */
void cleanupSwapChainDependantResources(); void cleanupSwapChainDependantResources();
/** /**
@ -121,8 +121,8 @@ namespace gz::vk {
* @brief Recreates swap chain dependant resources * @brief Recreates swap chain dependant resources
* @details * @details
* Calls: * Calls:
* -# cleanupSwapChainDependantResources * -# cleanupSwapChainDependantResources()
* -# initSwapChainDependantResources * -# initSwapChainDependantResources()
*/ */
void swapChainRecreateCallback(); void swapChainRecreateCallback();
/// @} /// @}

377
src/renderer/renderer3D.cpp
View File

@ -1,11 +1,14 @@
#include "renderer3D.hpp" #include "renderer3D.hpp"
#include "vertex.hpp"
#include "vulkan_instance.hpp" #include "vulkan_instance.hpp"
#include "texture_manager.hpp" #include "texture_manager.hpp"
#include "exceptions.hpp" #include "exceptions.hpp"
#include "vk_enum_string.h" #include "vk_enum_string.h"
#include <cstring> #include <cstring>
#include <vulkan/vulkan_core.h>
#include <chrono>
namespace gz::vk { namespace gz::vk {
// //
@ -25,23 +28,30 @@ namespace gz::vk {
vk.registerSwapChainRecreateCallback(std::bind(&Renderer3D::swapChainRecreateCallback, this)); vk.registerSwapChainRecreateCallback(std::bind(&Renderer3D::swapChainRecreateCallback, this));
vk.createCommandBuffers(commandBuffers); vk.createCommandBuffers(commandBuffers);
const size_t vertexCount = 500; const size_t vertexCount = 20000;
const size_t indexCount = 1000; const size_t indexCount = 10000;
vk.createVertexBuffer<Vertex3D>(vertexCount, vertexBuffer, vertexBufferMemory, vertexBufferSize); vk.createVertexBuffer<Vertex3D>(vertexCount, vertexBuffer, vertexBufferMemory, vertexBufferSize);
vk.createIndexBuffer<uint32_t>(indexCount, indexBuffer, indexBufferMemory, indexBufferSize); vk.createIndexBuffer<uint32_t>(indexCount, indexBuffer, indexBufferMemory, indexBufferSize);
rLog("Created Renderer3D"); rLog("Created Renderer3D");
// TODO
loadModel();
createUniformBuffers();
createDescriptorResources();
initSwapChainDependantResources(); initSwapChainDependantResources();
VulkanInstance::registerObjectUsingVulkan(ObjectUsingVulkan("Renderer3D", VulkanInstance::registerObjectUsingVulkan(ObjectUsingVulkan("Renderer3D",
{ &pipelines[PL_3D].pipeline, &renderPass, &vertexBuffer, &vertexBufferMemory, &indexBuffer, &indexBufferMemory }, { &pipelines[PL_3D].pipeline, &renderPass, &vertexBuffer, &vertexBufferMemory, &indexBuffer, &indexBufferMemory,
{ &framebuffers, &images, &imageMemory, &imageViews, &commandBuffers })); &descriptorSetLayout, &descriptorPool, },
{ &framebuffers, &images, &imageMemory, &imageViews, &commandBuffers,
&descriptorSets }));
rLog("Created Renderer3D"); rLog("Created Renderer3D");
} }
void Renderer3D::cleanup() { void Renderer3D::cleanup() {
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) { for (size_t i = 0; i < vk.getMaxFramesInFlight(); i++) {
vkDestroyBuffer(vk.device, uniformBuffers[i], nullptr); vkDestroyBuffer(vk.getDevice(), uniformBuffers[i], nullptr);
vkFreeMemory(vk.device, uniformBuffersMemory[i], nullptr); vkFreeMemory(vk.getDevice(), uniformBuffersMemory[i], nullptr);
} }
cleanupSwapChainDependantResources(); cleanupSwapChainDependantResources();
cleanup_(); cleanup_();
@ -55,23 +65,23 @@ namespace gz::vk {
createRenderPass(); createRenderPass();
createImages(); createImages();
vk.createFramebuffers(framebuffers, imageViews, renderPass); vk.createFramebuffers(framebuffers, imageViews, renderPass);
std::vector<VkDescriptorSetLayout> descriptorSetLayouts = { textureManager.getDescriptorSetLayout() }; std::vector<VkDescriptorSetLayout> descriptorSetLayouts = { descriptorSetLayout };
vk.createGraphicsPipeline<Vertex2D>("shaders/vert2D.spv", "shaders/frag2D.spv", descriptorSetLayouts, false, renderPass, pipelines[PL_2D]); vk.createGraphicsPipeline<Vertex3D>("shaders/vert.spv", "shaders/frag.spv", descriptorSetLayouts, false, renderPass, pipelines[PL_3D]);
} }
void Renderer3D::cleanupSwapChainDependantResources() { void Renderer3D::cleanupSwapChainDependantResources() {
// destroy pipelines // destroy pipelines
pipelines.destroy(vk.device); pipelines.destroy(vk.getDevice());
vk.destroyFramebuffers(framebuffers); vk.destroyFramebuffers(framebuffers);
for (size_t i = 0; i < images.size(); i++) { for (size_t i = 0; i < images.size(); i++) {
vkDestroyImageView(vk.device, imageViews[i], nullptr); vkDestroyImageView(vk.getDevice(), imageViews[i], nullptr);
vkDestroyImage(vk.device, images[i], nullptr); vkDestroyImage(vk.getDevice(), images[i], nullptr);
vkFreeMemory(vk.device, imageMemory[i], nullptr); vkFreeMemory(vk.getDevice(), imageMemory[i], nullptr);
} }
vkDestroyRenderPass(vk.device, renderPass, nullptr); vkDestroyRenderPass(vk.getDevice(), renderPass, nullptr);
} }
@ -87,13 +97,13 @@ namespace gz::vk {
// IMAGES // IMAGES
// //
void Renderer3D::createImages() { void Renderer3D::createImages() {
images.resize(vk.scImages.size()); images.resize(vk.getScImages().size());
imageMemory.resize(vk.scImages.size()); imageMemory.resize(vk.getScImages().size());
imageViews.resize(vk.scImages.size()); imageViews.resize(vk.getScImages().size());
VkImageUsageFlags usage= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; VkImageUsageFlags usage= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
for (size_t i = 0; i < images.size(); i++) { for (size_t i = 0; i < images.size(); i++) {
vk.createImage(vk.scExtent.width, vk.scExtent.height, vk.scImageFormat, VK_IMAGE_TILING_OPTIMAL, usage, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, images[i], imageMemory[i]); vk.createImage(vk.getScExtent().width, vk.getScExtent().height, vk.getScImageFormat(), VK_IMAGE_TILING_OPTIMAL, usage, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, images[i], imageMemory[i]);
vk.createImageView(vk.scImageFormat, images[i], imageViews[i], VK_IMAGE_ASPECT_COLOR_BIT); vk.createImageView(vk.getScImageFormat(), images[i], imageViews[i], VK_IMAGE_ASPECT_COLOR_BIT);
} }
} }
@ -104,7 +114,7 @@ namespace gz::vk {
void Renderer3D::createRenderPass() { void Renderer3D::createRenderPass() {
VkAttachmentDescription2 colorBlendAttachment{}; VkAttachmentDescription2 colorBlendAttachment{};
colorBlendAttachment.sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2; colorBlendAttachment.sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
colorBlendAttachment.format = vk.scImageFormat; colorBlendAttachment.format = vk.getScImageFormat();
colorBlendAttachment.samples = VK_SAMPLE_COUNT_1_BIT; colorBlendAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorBlendAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; colorBlendAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorBlendAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; colorBlendAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
@ -150,21 +160,21 @@ namespace gz::vk {
// dependecy for the image layout transition to transfer dst // dependecy for the image layout transition to transfer dst
VkSubpassDependency2 layoutTransitionSD{}; VkSubpassDependency2 layoutTransitionSD{};
colorAttachmentSD.sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; layoutTransitionSD.sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2;
colorAttachmentSD.srcSubpass = 0; layoutTransitionSD.srcSubpass = 0;
colorAttachmentSD.dstSubpass = VK_SUBPASS_EXTERNAL; layoutTransitionSD.dstSubpass = VK_SUBPASS_EXTERNAL;
colorAttachmentSD.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT; layoutTransitionSD.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
colorAttachmentSD.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT; layoutTransitionSD.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
colorAttachmentSD.dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT; layoutTransitionSD.dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
colorAttachmentSD.dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT; layoutTransitionSD.dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT;
colorAttachmentSD.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; layoutTransitionSD.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
/* VkSubpassDependency dependency{}; */ VkSubpassDependency dependency{};
/* dependency.srcSubpass = VK_SUBPASS_EXTERNAL; */ dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
/* dependency.dstSubpass = 0; */ dependency.dstSubpass = 0;
/* dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; */ dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
/* dependency.srcAccessMask = 0; */ dependency.srcAccessMask = 0;
/* dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; */ dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
/* dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; */ dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
/* std::array<VkAttachmentDescription, 2> attachments = { colorBlendAttachment, depthAttachment }; */ /* std::array<VkAttachmentDescription, 2> attachments = { colorBlendAttachment, depthAttachment }; */
std::vector<VkAttachmentDescription2> attachments = { colorBlendAttachment }; std::vector<VkAttachmentDescription2> attachments = { colorBlendAttachment };
@ -181,38 +191,15 @@ namespace gz::vk {
/* renderPassCI.pDependencies = nullptr; */ /* renderPassCI.pDependencies = nullptr; */
/* renderPassCI.correlatedViewMaskCount = 0; */ /* renderPassCI.correlatedViewMaskCount = 0; */
/* renderPassCI.pCorrelatedViewMasks = nullptr; */ /* renderPassCI.pCorrelatedViewMasks = nullptr; */
VkResult result = vkCreateRenderPass2(vk.device, &renderPassCI, nullptr, &renderPass); VkResult result = vkCreateRenderPass2(vk.getDevice(), &renderPassCI, nullptr, &renderPass);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
throw getVkException(result, "Could not create render pass", "Renderer3D::createRenderPass"); throw getVkException(result, "Could not create render pass", "Renderer3D::createRenderPass");
} }
rLog("createRenderPass: Created render pass."); rLog.log0("createRenderPass: Created render pass.");
} }
void Renderer3D::updateUniformBuffer() {
static auto startTime = std::chrono::high_resolution_clock::now();
auto currentTime = std::chrono::high_resolution_clock::now();
float time = std::chrono::duration<float, std::chrono::seconds::period>(currentTime - startTime).count();
// TODO use push constant instead of ubo
UniformBufferObject ubo{};
ubo.model = glm::rotate(glm::mat4(1.0f), time * std::numbers::pi_v<float> / 2, glm::vec3(0.0f, 0.0f, 1.0f));
ubo.view = glm::lookAt(glm::vec3(2.0f, 2.0f, 2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f));
ubo.projection = glm::perspective(glm::radians(45.0f), static_cast<float>(vk.scExtent.width) / vk.scExtent.height, 1.0f, 10.0f);
/* ubo.model = glm::mat4(1); */
/* ubo.view = glm::mat4(1); */
/* ubo.projection = glm::mat4(1); */
/* ubo.projection[1][1] *= -1; // y coordinate inverted in opengl */
void* data;
vkMapMemory(vk.device, uniformBuffersMemory[vk.currentFrame], NO_OFFSET, sizeof(ubo), NO_FLAGS, &data);
memcpy(data, &ubo, sizeof(ubo));
vkUnmapMemory(vk.device, uniformBuffersMemory[vk.currentFrame]);
}
// //
// DESCRIPTORS // DESCRIPTORS
// //
@ -240,36 +227,36 @@ namespace gz::vk {
// POOL // POOL
std::array<VkDescriptorPoolSize, 2> poolSizes; std::array<VkDescriptorPoolSize, 2> poolSizes;
poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSizes[0].descriptorCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT); poolSizes[0].descriptorCount = static_cast<uint32_t>(vk.getMaxFramesInFlight());
poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
poolSizes[1].descriptorCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT); poolSizes[1].descriptorCount = static_cast<uint32_t>(vk.getMaxFramesInFlight());
VkDescriptorPoolCreateInfo poolCI{}; VkDescriptorPoolCreateInfo poolCI{};
poolCI.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; poolCI.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolCI.poolSizeCount = static_cast<uint32_t>(poolSizes.size()); poolCI.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
poolCI.pPoolSizes = poolSizes.data(); poolCI.pPoolSizes = poolSizes.data();
poolCI.maxSets = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT); poolCI.maxSets = static_cast<uint32_t>(vk.getMaxFramesInFlight());
VkResult result = vkCreateDescriptorPool(vk.device, &poolCI, nullptr, &descriptorPool); VkResult result = vkCreateDescriptorPool(vk.getDevice(), &poolCI, nullptr, &descriptorPool);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
throw getVkException(result, "Failed to create descriptor pool", "Renderer3D::createDescriptorResources"); throw getVkException(result, "Failed to create descriptor pool", "Renderer3D::createDescriptorResources");
} }
// SETS // SETS
std::vector<VkDescriptorSetLayout> layouts(MAX_FRAMES_IN_FLIGHT, descriptorSetLayout); std::vector<VkDescriptorSetLayout> layouts(vk.getMaxFramesInFlight(), descriptorSetLayout);
VkDescriptorSetAllocateInfo setAI{}; VkDescriptorSetAllocateInfo setAI{};
setAI.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; setAI.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
setAI.descriptorPool = descriptorPool; setAI.descriptorPool = descriptorPool;
setAI.descriptorSetCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT); setAI.descriptorSetCount = static_cast<uint32_t>(layouts.size());
setAI.pSetLayouts = layouts.data(); setAI.pSetLayouts = layouts.data();
descriptorSets.resize(MAX_FRAMES_IN_FLIGHT); descriptorSets.resize(vk.getMaxFramesInFlight());
result = vkAllocateDescriptorSets(vk.device, &setAI, descriptorSets.data()); result = vkAllocateDescriptorSets(vk.getDevice(), &setAI, descriptorSets.data());
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
throw getVkException(result, "Failed to create descriptor sets", "Renderer3D::createDescriptorResources"); throw getVkException(result, "Failed to create descriptor sets", "Renderer3D::createDescriptorResources");
} }
// configure sets // configure sets
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) { for (size_t i = 0; i < vk.getMaxFramesInFlight(); i++) {
VkDescriptorBufferInfo bufferI{}; VkDescriptorBufferInfo bufferI{};
bufferI.buffer = uniformBuffers[i]; bufferI.buffer = uniformBuffers[i];
bufferI.offset = 0; bufferI.offset = 0;
@ -277,9 +264,8 @@ namespace gz::vk {
VkDescriptorImageInfo imageI{}; VkDescriptorImageInfo imageI{};
imageI.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; imageI.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
// TODO imageI.imageView = textureManager.getTextureAtlas().getTextureImageView();
/* imageI.imageView = textureImageView; */ imageI.sampler = textureManager.getTextureAtlas().getTextureSampler();
/* imageI.sampler = textureSampler; */
std::array<VkWriteDescriptorSet, 2> descriptorW{}; std::array<VkWriteDescriptorSet, 2> descriptorW{};
descriptorW[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; descriptorW[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
@ -304,139 +290,158 @@ namespace gz::vk {
uint32_t descriptorWriteCount = static_cast<uint32_t>(descriptorW.size()); uint32_t descriptorWriteCount = static_cast<uint32_t>(descriptorW.size());
uint32_t descriptorCopyCount = 0; uint32_t descriptorCopyCount = 0;
vkUpdateDescriptorSets(vk.device, descriptorWriteCount, descriptorW.data(), descriptorCopyCount, nullptr); vkUpdateDescriptorSets(vk.getDevice(), descriptorWriteCount, descriptorW.data(), descriptorCopyCount, nullptr);
} }
rLog("createDescriptorResources: Created descriptor layouts, pool and sets."); rLog.log0("createDescriptorResources: Created descriptor layouts, pool and sets.");
} }
//
// MODEL
//
void Renderer3D::loadModel() {
// load model into VerticesAndIndices struct
rLog.log1("Renderer3D: loadModel: loading model");
vk.loadModel(model);
// TODO use correct type
VkDeviceSize requiredVertexBufferSize = model.vertices.size() * sizeof(Vertex3D);
VkDeviceSize requiredIndexBufferSize = model.indices.size() * sizeof(uint32_t);
if (requiredVertexBufferSize > vertexBufferSize) { throw VkException("Renderer3D::loadModel: vertex buffer too small"); }
if (requiredIndexBufferSize > indexBufferSize) { throw VkException("Renderer3D::loadModel: index buffer too small"); }
rLog.log0("Renderer3D: loadModel: filling vertex buffer");
// copy to vertexBuffer
// create staging buffer
VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory;
vk.createBuffer(requiredVertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);
// fill staging buffer
void* data;
vkMapMemory(vk.getDevice(), stagingBufferMemory, NO_OFFSET, requiredVertexBufferSize, NO_FLAGS, &data);
memcpy(data, model.vertices.data(), requiredVertexBufferSize);
vkUnmapMemory(vk.getDevice(), stagingBufferMemory);
// fill vertex buffer
vk.copyBuffer(stagingBuffer, vertexBuffer, requiredVertexBufferSize);
vkDestroyBuffer(vk.getDevice(), stagingBuffer, nullptr);
vkFreeMemory(vk.getDevice(), stagingBufferMemory, nullptr);
rLog.log0("Renderer3D: loadModel: filling index buffer");
data = nullptr;
stagingBuffer = VK_NULL_HANDLE;
stagingBufferMemory = VK_NULL_HANDLE;
// copy to index buffer
vk.createBuffer(requiredIndexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);
// fill staging buffer
vkMapMemory(vk.getDevice(), stagingBufferMemory, NO_OFFSET, requiredIndexBufferSize, NO_FLAGS, &data);
memcpy(data, model.indices.data(), requiredIndexBufferSize);
vkUnmapMemory(vk.getDevice(), stagingBufferMemory);
// fill index buffer
vk.copyBuffer(stagingBuffer, indexBuffer, requiredIndexBufferSize);
vkDestroyBuffer(vk.getDevice(), stagingBuffer, nullptr);
vkFreeMemory(vk.getDevice(), stagingBufferMemory, nullptr);
}
// //
// RENDERING // RENDERING
// //
void Renderer3D::recordCommandBuffer(uint32_t imageIndex, uint32_t currentFrame) {} void Renderer3D::recordCommandBuffer(uint32_t imageIndex, uint32_t currentFrame) {
/* VkCommandBufferBeginInfo commandBufferBI{}; */ VkCommandBufferBeginInfo commandBufferBI{};
/* commandBufferBI.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; */ commandBufferBI.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
/* /1* commandBufferBI.flags = 0; *1/ */ commandBufferBI.flags = 0;
/* /1* commandBufferBI.pInheritanceInfo = nullptr; *1/ */ commandBufferBI.pInheritanceInfo = nullptr;
/* VkResult result = vkBeginCommandBuffer(commandBuffers[currentFrame], &commandBufferBI); */ VkResult result = vkBeginCommandBuffer(commandBuffers[currentFrame], &commandBufferBI);
/* if (result != VK_SUCCESS) { */ if (result != VK_SUCCESS) {
/* throw getVkException(result, "Failed to begin 2D command buffer", "Renderer3D::recordCommandBuffer"); */ throw getVkException(result, "Failed to begin 3D command buffer", "Renderer3D::recordCommandBuffer");
/* } */ }
/* VkRenderPassBeginInfo renderPassBI{}; */ VkRenderPassBeginInfo renderPassBI{};
/* renderPassBI.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; */ renderPassBI.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
/* renderPassBI.renderPass = renderPass; */ renderPassBI.renderPass = renderPass;
/* renderPassBI.framebuffer = framebuffers[imageIndex]; */ renderPassBI.framebuffer = framebuffers[imageIndex];
/* renderPassBI.renderArea.offset = { 0, 0 }; */ renderPassBI.renderArea.offset = { 0, 0 };
/* renderPassBI.renderArea.extent = vk.scExtent; */ renderPassBI.renderArea.extent = vk.getScExtent();
/* // clear */ // clear
/* std::array<VkClearValue, 1> clearValues{}; */ std::array<VkClearValue, 1> clearValues{};
/* clearValues[0].color = {{1.0f, 0.0f, 0.0f, 1.0f}}; */ clearValues[0].color = {{1.0f, 0.0f, 0.0f, 1.0f}};
/* /1* clearValues[1].depthStencil = {1.0f, 0}; *1/ */ /* clearValues[1].depthStencil = {1.0f, 0}; */
/* renderPassBI.clearValueCount = static_cast<uint32_t>(clearValues.size()); */ renderPassBI.clearValueCount = static_cast<uint32_t>(clearValues.size());
/* renderPassBI.pClearValues = clearValues.data(); */ renderPassBI.pClearValues = clearValues.data();
/* vkCmdBeginRenderPass(commandBuffers[currentFrame], &renderPassBI, VK_SUBPASS_CONTENTS_INLINE); */ vkCmdBeginRenderPass(commandBuffers[currentFrame], &renderPassBI, VK_SUBPASS_CONTENTS_INLINE);
/* vkCmdBindPipeline(commandBuffers[currentFrame], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[PL_2D].pipeline); */ vkCmdBindPipeline(commandBuffers[currentFrame], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[PL_3D].pipeline);
/* VkBuffer vertexBuffers[] = { vertexBuffer }; */ VkBuffer vertexBuffers[] = { vertexBuffer };
/* VkDeviceSize offsets[] = {0}; */ VkDeviceSize offsets[] = {0};
/* uint32_t bindingCount = 1; */ uint32_t bindingCount = 1;
/* vkCmdBindVertexBuffers(commandBuffers[currentFrame], BINDING, bindingCount, vertexBuffers, offsets); */ vkCmdBindVertexBuffers(commandBuffers[currentFrame], BINDING, bindingCount, vertexBuffers, offsets);
/* // TODO use correct index type! */ // TODO use correct index type!
/* vkCmdBindIndexBuffer(commandBuffers[currentFrame], indexBuffer, NO_OFFSET, VK_INDEX_TYPE_UINT32); */ vkCmdBindIndexBuffer(commandBuffers[currentFrame], indexBuffer, NO_OFFSET, VK_INDEX_TYPE_UINT32);
/* uint32_t descriptorCount = 1; */ uint32_t descriptorCount = 1;
/* uint32_t firstSet = 0; */ uint32_t firstSet = 0;
/* uint32_t dynamicOffsetCount = 0; */ uint32_t dynamicOffsetCount = 0;
/* uint32_t* dynamicOffsets = nullptr; */ uint32_t* dynamicOffsets = nullptr;
/* vkCmdBindDescriptorSets(commandBuffers[currentFrame], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[PL_2D].layout, firstSet, descriptorCount, &textureManager.getDescriptorSet(), dynamicOffsetCount, dynamicOffsets); */ vkCmdBindDescriptorSets(commandBuffers[currentFrame], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[PL_3D].layout, firstSet, descriptorCount, &descriptorSets[currentFrame], dynamicOffsetCount, dynamicOffsets);
/* int instanceCount = 1; */
/* int firstIndex = 0; */
/* int firstInstance = 0; */
/* vkCmdDrawIndexed(commandBuffers[currentFrame], static_cast<uint32_t>(shapesIndicesCount), instanceCount, firstIndex, NO_OFFSET, firstInstance); */
/* vkCmdEndRenderPass(commandBuffers[currentFrame]); */
/* vk.copyImageToImage(commandBuffers[currentFrame], images[imageIndex], vk.scImages[imageIndex], vk.scExtent); */
/* result = vkEndCommandBuffer(commandBuffers[currentFrame]); */
/* if (result != VK_SUCCESS) { */
/* rLog.error("Failed to record 2D - command buffer", "VkResult:", STR_VK_RESULT(result)); */
/* throw getVkException(result, "Failed to record 2D - command buffer", "Renderer3D::recordCommandBufferWithTexture"); */
/* } */
/* vk.submitThisFrame(commandBuffers[currentFrame]); */
/* } */
/* void Renderer3D::fillVertexBufferWithShapes() { */
/* rLog("fillVertexBufferWithShapes"); */
/* if (vertexBufferSize < shapesVerticesCount * sizeof(Vertex2D)) { */
/* throw VkException("vertex buffer too small! vertexBufferSize: " + std::to_string(vertexBufferSize) + ", required size: " + std::to_string(shapesVerticesCount), "fillVertexBufferWithShapes"); */
/* } */
/* // create staging buffer */
/* VkBuffer stagingBuffer; */
/* VkDeviceMemory stagingBufferMemory; */
/* vk.createBuffer(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory); */
/* // fill staging buffer */
/* void* data; */
/* vkMapMemory(vk.device, stagingBufferMemory, NO_OFFSET, vertexBufferSize, NO_FLAGS, &data); */
/* Vertex2D* vdata = reinterpret_cast<Vertex2D*>(data); */
/* size_t offset = 0; */
/* for (auto it = shapes.begin(); it != shapes.end(); it++) { */
/* rLog("fillVertexBufferWithShapes: copying vertex buffer nr", it - shapes.begin(), "-", it->getVertices(), "to address:", long(vdata + offset), " offset:", offset); */
/* memcpy(vdata+offset, it->getVertices().data(), it->getVertices().size() * sizeof(Vertex2D)); */
/* offset += it->getVertices().size(); */
/* } */
/* vkUnmapMemory(vk.device, stagingBufferMemory); */
/* // fill vertex buffer */
/* vk.copyBuffer(stagingBuffer, vertexBuffer, vertexBufferSize); */
/* vkDestroyBuffer(vk.device, stagingBuffer, nullptr); */
/* vkFreeMemory(vk.device, stagingBufferMemory, nullptr); */
/* } */
/* void Renderer3D::fillIndexBufferWithShapes() { */
/* rLog("fillIndexBufferWithShapes"); */
/* if (indexBufferSize < shapesIndicesCount * sizeof(uint32_t)) { */
/* throw VkException("index buffer too small! indexBufferSize: " + std::to_string(vertexBufferSize) + ", required size: " + std::to_string(shapesVerticesCount), "fillVertexBufferWithShapes"); */
/* } */
/* // create staging buffer */
/* VkBuffer stagingBuffer; */
/* VkDeviceMemory stagingBufferMemory; */
/* vk.createBuffer(indexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory); */
/* // fill staging buffer */
/* void* data; */
/* vkMapMemory(vk.device, stagingBufferMemory, NO_OFFSET, indexBufferSize, NO_FLAGS, &data); */
/* uint32_t* idata = reinterpret_cast<uint32_t*>(data); */
/* size_t offset = 0; */
/* for (auto it = shapes.begin(); it != shapes.end(); it++) { */
/* rLog("fillIndexBufferWithShapes: copying index buffer nr", it - shapes.begin(), "-", it->getIndices(), "to address:", long(idata + offset), " offset:", offset); */
/* memcpy(idata+offset, it->getIndices().data(), it->getIndices().size() * sizeof(uint32_t)); */
/* offset += it->getIndices().size(); */
/* } */
/* rLog("fillIndexBufferWithShapes: indices count:", shapesIndicesCount); */
/* vkUnmapMemory(vk.device, stagingBufferMemory); */
/* // fill index buffer */
/* vk.copyBuffer(stagingBuffer, indexBuffer, indexBufferSize); */
/* vkDestroyBuffer(vk.device, stagingBuffer, nullptr); */
/* vkFreeMemory(vk.device, stagingBufferMemory, nullptr); */
/* } */
int instanceCount = 1;
int firstIndex = 0;
int firstInstance = 0;
vkCmdDrawIndexed(commandBuffers[currentFrame], static_cast<uint32_t>(model.indices.size()), instanceCount, firstIndex, NO_OFFSET, firstInstance);
vkCmdEndRenderPass(commandBuffers[currentFrame]);
vk.copyImageToImage(commandBuffers[currentFrame], images[imageIndex], vk.getScImages()[imageIndex], vk.getScExtent());
result = vkEndCommandBuffer(commandBuffers[currentFrame]);
if (result != VK_SUCCESS) {
rLog.error("Failed to record 3D - command buffer", "VkResult:", STR_VK_RESULT(result));
throw getVkException(result, "Failed to record 3D - command buffer", "Renderer3D::recordCommandBuffer");
}
vk.submitThisFrame(commandBuffers[currentFrame]);
}
// //
// RENDERING // RENDERING
// //
void Renderer3D::drawFrame(uint32_t imageIndex) { void Renderer3D::drawFrame(uint32_t imageIndex) {
vkResetCommandBuffer(commandBuffers[vk.currentFrame], NO_FLAGS); vkResetCommandBuffer(commandBuffers[vk.getCurrentFrame()], NO_FLAGS);
/* recordCommandBuffer(imageIndex, vk.currentFrame); */ /* recordCommandBuffer(imageIndex, vk.getCurrentFrame()); */
recordCommandBuffer(imageIndex, vk.currentFrame); updateUniformBuffer();
recordCommandBuffer(imageIndex, vk.getCurrentFrame());
} }
void Renderer3D::createUniformBuffers() {
VkDeviceSize bufferSize = sizeof(UniformBufferObject);
uniformBuffers.resize(vk.getMaxFramesInFlight());
uniformBuffersMemory.resize(vk.getMaxFramesInFlight());
for (size_t i = 0; i < vk.getMaxFramesInFlight(); i++) {
vk.createBuffer(bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, uniformBuffers[i], uniformBuffersMemory[i]);
}
}
void Renderer3D::updateUniformBuffer() {
static auto startTime = std::chrono::high_resolution_clock::now();
auto currentTime = std::chrono::high_resolution_clock::now();
float time = std::chrono::duration<float, std::chrono::seconds::period>(currentTime - startTime).count();
// TODO use push constant instead of ubo
UniformBufferObject ubo{};
ubo.model = glm::rotate(glm::mat4(1.0f), time * std::numbers::pi_v<float> / 2, glm::vec3(0.0f, 0.0f, 1.0f));
ubo.view = glm::lookAt(glm::vec3(2.0f, 2.0f, 2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f));
ubo.projection = glm::perspective(glm::radians(45.0f), static_cast<float>(vk.getScExtent().width) / vk.getScExtent().height, 1.0f, 10.0f);
/* ubo.model = glm::mat4(1); */
/* ubo.view = glm::mat4(1); */
/* ubo.projection = glm::mat4(1); */
/* ubo.projection[1][1] *= -1; // y coordinate inverted in opengl */
void* data;
vkMapMemory(vk.getDevice(), uniformBuffersMemory[vk.getCurrentFrame()], NO_OFFSET, sizeof(ubo), NO_FLAGS, &data);
memcpy(data, &ubo, sizeof(ubo));
vkUnmapMemory(vk.getDevice(), uniformBuffersMemory[vk.getCurrentFrame()]);
}

17
src/renderer/renderer3D.hpp
View File

@ -17,10 +17,12 @@ namespace gz::vk {
* @brief Create a 3D renderer * @brief Create a 3D renderer
* @details * @details
* -# @ref VulkanInstance::registerCleanupCallback "register" @ref cleanup() "cleanup callback" * -# @ref VulkanInstance::registerCleanupCallback "register" @ref cleanup() "cleanup callback"
* -# @ref VulkanInstance::registerSwapChainRecreateCallback "register" @ref swapChainRecreateCallback "swapChain recreation callback" * -# @ref VulkanInstance::registerSwapChainRecreateCallback "register" @ref swapChainRecreateCallback() "swapChain recreation callback"
* -# create command buffers * -# create command buffers
* -# create vertex & index buffers * -# create vertex & index buffers
* -# call initSwapChainDependantResources * -# call createUniformBuffers()
* -# call createDescriptorResources()
* -# call initSwapChainDependantResources()
*/ */
Renderer3D(VulkanInstance& instance, TextureManager& textureManager); Renderer3D(VulkanInstance& instance, TextureManager& textureManager);
/** /**
@ -33,6 +35,7 @@ namespace gz::vk {
void recordCommandBuffer(uint32_t imageIndex, uint32_t currentFrame); void recordCommandBuffer(uint32_t imageIndex, uint32_t currentFrame);
std::vector<VkBuffer> uniformBuffers; std::vector<VkBuffer> uniformBuffers;
std::vector<VkDeviceMemory> uniformBuffersMemory; std::vector<VkDeviceMemory> uniformBuffersMemory;
void createUniformBuffers();
void updateUniformBuffer(); void updateUniformBuffer();
/** /**
@ -55,7 +58,7 @@ namespace gz::vk {
* @details * @details
* Attachments: * Attachments:
* - color blend: * - color blend:
* - loadOp = VK_ATTACHMENT_LOAD_OP_LOAD (not clear!) * - loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR
* - storeOp = VK_ATTACHMENT_STORE_OP_STORE * - storeOp = VK_ATTACHMENT_STORE_OP_STORE
* - initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL * - initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
* - finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL * - finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
@ -123,8 +126,8 @@ namespace gz::vk {
* @brief Recreates swap chain dependant resources * @brief Recreates swap chain dependant resources
* @details * @details
* Calls: * Calls:
* -# cleanupSwapChainDependantResources * -# cleanupSwapChainDependantResources()
* -# initSwapChainDependantResources * -# initSwapChainDependantResources()
*/ */
void swapChainRecreateCallback(); void swapChainRecreateCallback();
/// @} /// @}
@ -139,7 +142,9 @@ namespace gz::vk {
*/ */
void cleanup(); void cleanup();
void loadModel();
VerticesAndIndices<uint32_t> model;
Log rLog; Log rLog;
}; };
} }

1
src/utility/exceptions.hpp
View File

@ -33,4 +33,5 @@ namespace gz {
* @brief Return a VkException with a formatted string * @brief Return a VkException with a formatted string
*/ */
VkException getVkException(VkResult result, std::string&& what="", std::string&& functionName=""); VkException getVkException(VkResult result, std::string&& what="", std::string&& functionName="");
} }

16
src/utility/texture_atlas.cpp
View File

@ -39,10 +39,10 @@ TextureAtlas::TextureAtlas(VulkanInstance& instance, uint16_t slotWidth, uint16_
void TextureAtlas::cleanup() { void TextureAtlas::cleanup() {
VulkanInstance::vLog("TextureAtlas::cleanup, textureSampler", reinterpret_cast<uint64_t>(textureSampler), "textureImageView", reinterpret_cast<uint64_t>(textureImageView)); VulkanInstance::vLog("TextureAtlas::cleanup, textureSampler", reinterpret_cast<uint64_t>(textureSampler), "textureImageView", reinterpret_cast<uint64_t>(textureImageView));
vkDestroySampler(vk.device, textureSampler, nullptr); vkDestroySampler(vk.getDevice(), textureSampler, nullptr);
vkDestroyImageView(vk.device, textureImageView, nullptr); vkDestroyImageView(vk.getDevice(), textureImageView, nullptr);
vkDestroyImage(vk.device, textureImage, nullptr); vkDestroyImage(vk.getDevice(), textureImage, nullptr);
vkFreeMemory(vk.device, textureImageMemory, nullptr); vkFreeMemory(vk.getDevice(), textureImageMemory, nullptr);
} }
@ -154,9 +154,9 @@ void TextureAtlas::blitTextureOnImage(uint8_t* pixels, uint16_t slotX, uint16_t
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
stagingBuffer, stagingBufferMemory); stagingBuffer, stagingBufferMemory);
void* data; void* data;
vkMapMemory(vk.device, stagingBufferMemory, NO_OFFSET, imageSize, NO_FLAGS, &data); vkMapMemory(vk.getDevice(), stagingBufferMemory, NO_OFFSET, imageSize, NO_FLAGS, &data);
memcpy(data, pixels, static_cast<size_t>(imageSize)); memcpy(data, pixels, static_cast<size_t>(imageSize));
vkUnmapMemory(vk.device, stagingBufferMemory); vkUnmapMemory(vk.getDevice(), stagingBufferMemory);
vk.transitionImageLayout(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); vk.transitionImageLayout(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
vk.copyBufferToImage(stagingBuffer, textureImage, vk.copyBufferToImage(stagingBuffer, textureImage,
@ -164,8 +164,8 @@ void TextureAtlas::blitTextureOnImage(uint8_t* pixels, uint16_t slotX, uint16_t
static_cast<uint32_t>(textureWidth), static_cast<uint32_t>(textureHeight)); // dimensions static_cast<uint32_t>(textureWidth), static_cast<uint32_t>(textureHeight)); // dimensions
vk.transitionImageLayout(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); vk.transitionImageLayout(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
vkDestroyBuffer(vk.device, stagingBuffer, nullptr); vkDestroyBuffer(vk.getDevice(), stagingBuffer, nullptr);
vkFreeMemory(vk.device, stagingBufferMemory, nullptr); vkFreeMemory(vk.getDevice(), stagingBufferMemory, nullptr);
} }

16
src/utility/texture_manager.cpp
View File

@ -21,9 +21,9 @@ namespace gz::vk {
void TextureManager::cleanup() { void TextureManager::cleanup() {
/* vkFreeDescriptorSets(vk.device, descriptorPool, 1, &descriptorSet); */ /* vkFreeDescriptorSets(vk.getDevice(), descriptorPool, 1, &descriptorSet); */
vkDestroyDescriptorSetLayout(vk.device, descriptorSetLayout, NO_ALLOC); vkDestroyDescriptorSetLayout(vk.getDevice(), descriptorSetLayout, NO_ALLOC);
vkDestroyDescriptorPool(vk.device, descriptorPool, NO_ALLOC); vkDestroyDescriptorPool(vk.getDevice(), descriptorPool, NO_ALLOC);
} }
@ -73,7 +73,7 @@ void TextureManager::createDescriptorSetLayout() {
descriptorSetLayoutCI.bindingCount = 1; descriptorSetLayoutCI.bindingCount = 1;
descriptorSetLayoutCI.pBindings = &samplerLayoutBinding; descriptorSetLayoutCI.pBindings = &samplerLayoutBinding;
VkResult result = vkCreateDescriptorSetLayout(vk.device, &descriptorSetLayoutCI, nullptr, &descriptorSetLayout); VkResult result = vkCreateDescriptorSetLayout(vk.getDevice(), &descriptorSetLayoutCI, nullptr, &descriptorSetLayout);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
throw getVkException(result, "Could not create descriptorSetLayout", "TextureManager::createDescriptorSetLayout"); throw getVkException(result, "Could not create descriptorSetLayout", "TextureManager::createDescriptorSetLayout");
} }
@ -93,7 +93,7 @@ void TextureManager::createDescriptorPool() {
poolCI.poolSizeCount = static_cast<uint32_t>(poolSizes.size()); poolCI.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
poolCI.pPoolSizes = poolSizes.data(); poolCI.pPoolSizes = poolSizes.data();
poolCI.maxSets = 1; poolCI.maxSets = 1;
VkResult result = vkCreateDescriptorPool(vk.device, &poolCI, nullptr, &descriptorPool); VkResult result = vkCreateDescriptorPool(vk.getDevice(), &poolCI, nullptr, &descriptorPool);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
throw getVkException(result, "Failed to create descriptor pool", "TextureManager::createDescriptorPool"); throw getVkException(result, "Failed to create descriptor pool", "TextureManager::createDescriptorPool");
} }
@ -112,8 +112,8 @@ void TextureManager::createDescriptorSet() {
setAI.pSetLayouts = &descriptorSetLayout; setAI.pSetLayouts = &descriptorSetLayout;
/* descriptorSets.resize(MAX_FRAMES_IN_FLIGHT); */ /* descriptorSets.resize(MAX_FRAMES_IN_FLIGHT); */
/* VkResult result = vkAllocateDescriptorSets(vk.device, &setAI, descriptorSets.data()); */ /* VkResult result = vkAllocateDescriptorSets(vk.getDevice(), &setAI, descriptorSets.data()); */
VkResult result = vkAllocateDescriptorSets(vk.device, &setAI, &descriptorSet); VkResult result = vkAllocateDescriptorSets(vk.getDevice(), &setAI, &descriptorSet);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
throw getVkException(result, "Failed to create descriptor set", "TextureManager::createDescriptorPool"); throw getVkException(result, "Failed to create descriptor set", "TextureManager::createDescriptorPool");
} }
@ -138,7 +138,7 @@ void TextureManager::createDescriptorSet() {
uint32_t descriptorWriteCount = static_cast<uint32_t>(descriptorW.size()); uint32_t descriptorWriteCount = static_cast<uint32_t>(descriptorW.size());
uint32_t descriptorCopyCount = 0; uint32_t descriptorCopyCount = 0;
vkUpdateDescriptorSets(vk.device, descriptorWriteCount, descriptorW.data(), descriptorCopyCount, nullptr); vkUpdateDescriptorSets(vk.getDevice(), descriptorWriteCount, descriptorW.data(), descriptorCopyCount, nullptr);
/* } */ /* } */
/* vLog("createDescriptorSets: Created descriptor sets."); */ /* vLog("createDescriptorSets: Created descriptor sets."); */
} }

3
src/utility/texture_manager.hpp
View File

@ -27,6 +27,9 @@ namespace gz::vk {
void getTexCoords(const std::string& textureName, glm::vec2& texCoords); void getTexCoords(const std::string& textureName, glm::vec2& texCoords);
const VkDescriptorSet& getDescriptorSet() const { return descriptorSet; } const VkDescriptorSet& getDescriptorSet() const { return descriptorSet; }
const VkDescriptorSetLayout& getDescriptorSetLayout() const { return descriptorSetLayout; } const VkDescriptorSetLayout& getDescriptorSetLayout() const { return descriptorSetLayout; }
// TODO
/// @todo take texture as argument
const TextureAtlas& getTextureAtlas() const { return atlases.at(0); };
private: private:

6
src/utility/vulkan_util.cpp
View File

@ -68,18 +68,18 @@ namespace gz::vk {
return true; return true;
} }
void PipelineContainer::erase(const PipelineT& key, VkDevice& device, const VkAllocationCallbacks* pAllocator) { void PipelineContainer::erase(const PipelineT& key, const VkDevice& device, const VkAllocationCallbacks* pAllocator) {
vkDestroyPipeline(device, pipelines[key].pipeline, pAllocator); vkDestroyPipeline(device, pipelines[key].pipeline, pAllocator);
vkDestroyPipelineLayout(device, pipelines[key].layout, pAllocator); vkDestroyPipelineLayout(device, pipelines[key].layout, pAllocator);
pipelines.erase(pipelines.find(key)); pipelines.erase(pipelines.find(key));
} }
PipelineContainer::iterator PipelineContainer::erase(const PipelineContainer::iterator& it, VkDevice& device, const VkAllocationCallbacks* pAllocator) { PipelineContainer::iterator PipelineContainer::erase(const PipelineContainer::iterator& it, const VkDevice& device, const VkAllocationCallbacks* pAllocator) {
vkDestroyPipeline(device, it->second.pipeline, pAllocator); vkDestroyPipeline(device, it->second.pipeline, pAllocator);
vkDestroyPipelineLayout(device, it->second.layout, pAllocator); vkDestroyPipelineLayout(device, it->second.layout, pAllocator);
return pipelines.erase(it); return pipelines.erase(it);
} }
void PipelineContainer::destroy(VkDevice& device, const VkAllocationCallbacks* pAllocator) { void PipelineContainer::destroy(const VkDevice& device, const VkAllocationCallbacks* pAllocator) {
auto it = pipelines.begin(); while (it != pipelines.end()) { auto it = pipelines.begin(); while (it != pipelines.end()) {
it = erase(it, device); it = erase(it, device);
} }

6
src/utility/vulkan_util.hpp
View File

@ -53,15 +53,15 @@ namespace gz::vk {
/** /**
* @brief Destroy the pipeline+layout and then remove the handles from the underlying map * @brief Destroy the pipeline+layout and then remove the handles from the underlying map
*/ */
void erase(const PipelineT& key, VkDevice& device, const VkAllocationCallbacks* pAllocator=nullptr); void erase(const PipelineT& key, const VkDevice& device, const VkAllocationCallbacks* pAllocator=nullptr);
/** /**
* @brief Destroy the pipeline+layout and then remove the handles from the underlying map * @brief Destroy the pipeline+layout and then remove the handles from the underlying map
*/ */
iterator erase(const iterator& it, VkDevice& device, const VkAllocationCallbacks* pAllocator=nullptr); iterator erase(const iterator& it, const VkDevice& device, const VkAllocationCallbacks* pAllocator=nullptr);
/** /**
* @brief Destroy all pipelines#layouts and then remove the handles from the underlying map * @brief Destroy all pipelines#layouts and then remove the handles from the underlying map
*/ */
void destroy(VkDevice& device, const VkAllocationCallbacks* pAllocator=nullptr); void destroy(const VkDevice& device, const VkAllocationCallbacks* pAllocator=nullptr);
iterator begin() { return pipelines.begin(); } iterator begin() { return pipelines.begin(); }
iterator end() { return pipelines.end(); } iterator end() { return pipelines.end(); }
size_t size() const { return pipelines.size(); } size_t size() const { return pipelines.size(); }