Basic mutability framework

2022-01-12 14:40:26 +01:00
parent b2718dde70
commit 6d48267ec2
72 changed files with 1781 additions and 1341 deletions
@@ -10,277 +10,277 @@ using namespace Seele::Vulkan;

 struct PendingBuffer
 {
-	PStagingBuffer stagingBuffer;
-	Gfx::QueueType prevQueue;
-	bool bWriteOnly;
+    PStagingBuffer stagingBuffer;
+    Gfx::QueueType prevQueue;
+    bool bWriteOnly;
 };

 static Map<ShaderBuffer *, PendingBuffer> pendingBuffers;

 ShaderBuffer::ShaderBuffer(PGraphics graphics, uint32 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool bDynamic)
-	: graphics(graphics)
-	, currentBuffer(0)
-	, size(size)
-	, owner(queueType)
+    : graphics(graphics)
+    , currentBuffer(0)
+    , size(size)
+    , owner(queueType)
 {
-	if(bDynamic)
-	{
-		numBuffers = Gfx::numFramesBuffered;
-	} 
-	else
-	{
-		numBuffers = 1;
-	}
-	usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
-	usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
-	VkBufferCreateInfo info =
-		init::BufferCreateInfo(
-			usage,
-			size);
-	info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-	uint32 queueFamilyIndex =  graphics->getFamilyMapping().getQueueTypeFamilyIndex(queueType);
-	info.pQueueFamilyIndices = &queueFamilyIndex;
-	info.queueFamilyIndexCount = 0;
-	VkBufferMemoryRequirementsInfo2 bufferReqInfo;
-	bufferReqInfo.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
-	bufferReqInfo.pNext = nullptr;
-	VkMemoryDedicatedRequirements dedicatedRequirements;
-	dedicatedRequirements.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
-	dedicatedRequirements.pNext = nullptr;
-	VkMemoryRequirements2 memRequirements;
-	memRequirements.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
-	memRequirements.pNext = &dedicatedRequirements;
-	for (uint32 i = 0; i < numBuffers; ++i)
-	{
-		VK_CHECK(vkCreateBuffer(graphics->getDevice(), &info, nullptr, &buffers[i].buffer));
-		bufferReqInfo.buffer = buffers[i].buffer;
-		vkGetBufferMemoryRequirements2(graphics->getDevice(), &bufferReqInfo, &memRequirements);
-		auto temp = graphics->getAllocator()->allocate(memRequirements, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, buffers[i].buffer);
-		buffers[i].allocation = temp;
-		vkBindBufferMemory(graphics->getDevice(), buffers[i].buffer, buffers[i].allocation->getHandle(), buffers[i].allocation->getOffset());
-	}
+    if(bDynamic)
+    {
+        numBuffers = Gfx::numFramesBuffered;
+    } 
+    else
+    {
+        numBuffers = 1;
+    }
+    usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+    usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+    VkBufferCreateInfo info =
+        init::BufferCreateInfo(
+            usage,
+            size);
+    info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    uint32 queueFamilyIndex =  graphics->getFamilyMapping().getQueueTypeFamilyIndex(queueType);
+    info.pQueueFamilyIndices = &queueFamilyIndex;
+    info.queueFamilyIndexCount = 1;
+    VkBufferMemoryRequirementsInfo2 bufferReqInfo;
+    bufferReqInfo.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
+    bufferReqInfo.pNext = nullptr;
+    VkMemoryDedicatedRequirements dedicatedRequirements;
+    dedicatedRequirements.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
+    dedicatedRequirements.pNext = nullptr;
+    VkMemoryRequirements2 memRequirements;
+    memRequirements.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
+    memRequirements.pNext = &dedicatedRequirements;
+    for (uint32 i = 0; i < numBuffers; ++i)
+    {
+        VK_CHECK(vkCreateBuffer(graphics->getDevice(), &info, nullptr, &buffers[i].buffer));
+        bufferReqInfo.buffer = buffers[i].buffer;
+        vkGetBufferMemoryRequirements2(graphics->getDevice(), &bufferReqInfo, &memRequirements);
+        auto temp = graphics->getAllocator()->allocate(memRequirements, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, buffers[i].buffer);
+        buffers[i].allocation = temp;
+        vkBindBufferMemory(graphics->getDevice(), buffers[i].buffer, buffers[i].allocation->getHandle(), buffers[i].allocation->getOffset());
+    }
 }

 ShaderBuffer::~ShaderBuffer()
 {
-	PCmdBuffer cmdBuffer = graphics->getQueueCommands(owner)->getCommands();
-	VkDevice device = graphics->getDevice();
-	auto deletionLambda = [cmdBuffer, device](VkBuffer buffer) -> Job 
-	{
-		//co_await cmdBuffer->asyncWait();
-		//vkDestroyBuffer(device, buffer, nullptr);
+    PCmdBuffer cmdBuffer = graphics->getQueueCommands(owner)->getCommands();
+    VkDevice device = graphics->getDevice();
+    auto deletionLambda = [cmdBuffer, device](VkBuffer buffer) -> Job 
+    {
+        //co_await cmdBuffer->asyncWait();
+        //vkDestroyBuffer(device, buffer, nullptr);
        co_return;
    };
-	for (uint32 i = 0; i < numBuffers; ++i)
-	{
-		deletionLambda(buffers[i].buffer);
-		buffers[i].allocation = nullptr;
-	}
-	graphics = nullptr;
+    for (uint32 i = 0; i < numBuffers; ++i)
+    {
+        deletionLambda(buffers[i].buffer);
+        buffers[i].allocation = nullptr;
+    }
+    graphics = nullptr;
 }

 VkDeviceSize ShaderBuffer::getOffset() const
 {
-	return buffers[currentBuffer].allocation->getOffset();
+    return buffers[currentBuffer].allocation->getOffset();
 }

 void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-	VkBufferMemoryBarrier barrier =
-		init::BufferMemoryBarrier();
-	PCommandBufferManager sourceManager = graphics->getQueueCommands(owner);
-	PCommandBufferManager dstManager = nullptr;
-	VkPipelineStageFlags srcStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
-	VkPipelineStageFlags dstStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
-	Gfx::QueueFamilyMapping mapping = graphics->getFamilyMapping();
-	barrier.srcQueueFamilyIndex = mapping.getQueueTypeFamilyIndex(owner);
-	barrier.dstQueueFamilyIndex = mapping.getQueueTypeFamilyIndex(newOwner);
-	assert(barrier.srcQueueFamilyIndex != barrier.dstQueueFamilyIndex);
-	if (owner == Gfx::QueueType::TRANSFER || owner == Gfx::QueueType::DEDICATED_TRANSFER)
-	{
-		barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-		srcStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-	}
-	else if (owner == Gfx::QueueType::COMPUTE)
-	{
-		barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
-		srcStage = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
-	}
-	else if (owner == Gfx::QueueType::GRAPHICS)
-	{
-		barrier.srcAccessMask = getSourceAccessMask();
-		srcStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
-	}
-	if (newOwner == Gfx::QueueType::TRANSFER)
-	{
-		barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
-		dstStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-		dstManager = graphics->getTransferCommands();
-	}
-	else if (newOwner == Gfx::QueueType::DEDICATED_TRANSFER)
-	{
-		barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
-		dstStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-		dstManager = graphics->getDedicatedTransferCommands();
-	}
-	else if (newOwner == Gfx::QueueType::COMPUTE)
-	{
-		barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-		dstStage = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
-		dstManager = graphics->getComputeCommands();
-	}
-	else if (newOwner == Gfx::QueueType::GRAPHICS)
-	{
-		barrier.dstAccessMask = getDestAccessMask();
-		dstStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
-		dstManager = graphics->getGraphicsCommands();
-	}
-	VkCommandBuffer srcCommand = sourceManager->getCommands()->getHandle();
-	VkCommandBuffer dstCommand = dstManager->getCommands()->getHandle();
-	VkBufferMemoryBarrier dynamicBarriers[Gfx::numFramesBuffered];
-	barrier.offset = 0;
-	barrier.size = size;
-	for (uint32 i = 0; i < numBuffers; ++i)
-	{
-		dynamicBarriers[i] = barrier;
-		dynamicBarriers[i].buffer = buffers[i].buffer;
-	}
-	vkCmdPipelineBarrier(srcCommand, srcStage, srcStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
-	vkCmdPipelineBarrier(dstCommand, dstStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
-	sourceManager->submitCommands();
+    VkBufferMemoryBarrier barrier =
+        init::BufferMemoryBarrier();
+    PCommandBufferManager sourceManager = graphics->getQueueCommands(owner);
+    PCommandBufferManager dstManager = nullptr;
+    VkPipelineStageFlags srcStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+    VkPipelineStageFlags dstStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+    Gfx::QueueFamilyMapping mapping = graphics->getFamilyMapping();
+    barrier.srcQueueFamilyIndex = mapping.getQueueTypeFamilyIndex(owner);
+    barrier.dstQueueFamilyIndex = mapping.getQueueTypeFamilyIndex(newOwner);
+    assert(barrier.srcQueueFamilyIndex != barrier.dstQueueFamilyIndex);
+    if (owner == Gfx::QueueType::TRANSFER || owner == Gfx::QueueType::DEDICATED_TRANSFER)
+    {
+        barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+        srcStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
+    }
+    else if (owner == Gfx::QueueType::COMPUTE)
+    {
+        barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
+        srcStage = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+    }
+    else if (owner == Gfx::QueueType::GRAPHICS)
+    {
+        barrier.srcAccessMask = getSourceAccessMask();
+        srcStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+    }
+    if (newOwner == Gfx::QueueType::TRANSFER)
+    {
+        barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+        dstStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
+        dstManager = graphics->getTransferCommands();
+    }
+    else if (newOwner == Gfx::QueueType::DEDICATED_TRANSFER)
+    {
+        barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+        dstStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
+        dstManager = graphics->getDedicatedTransferCommands();
+    }
+    else if (newOwner == Gfx::QueueType::COMPUTE)
+    {
+        barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+        dstStage = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+        dstManager = graphics->getComputeCommands();
+    }
+    else if (newOwner == Gfx::QueueType::GRAPHICS)
+    {
+        barrier.dstAccessMask = getDestAccessMask();
+        dstStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+        dstManager = graphics->getGraphicsCommands();
+    }
+    VkCommandBuffer srcCommand = sourceManager->getCommands()->getHandle();
+    VkCommandBuffer dstCommand = dstManager->getCommands()->getHandle();
+    VkBufferMemoryBarrier dynamicBarriers[Gfx::numFramesBuffered];
+    barrier.offset = 0;
+    barrier.size = size;
+    for (uint32 i = 0; i < numBuffers; ++i)
+    {
+        dynamicBarriers[i] = barrier;
+        dynamicBarriers[i].buffer = buffers[i].buffer;
+    }
+    vkCmdPipelineBarrier(srcCommand, srcStage, srcStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
+    vkCmdPipelineBarrier(dstCommand, dstStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
+    sourceManager->submitCommands();
 }

 void ShaderBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
        VkAccessFlags dstAccess, VkPipelineStageFlags dstStage) 
 {
-	PCmdBuffer commandBuffer = graphics->getQueueCommands(owner)->getCommands();
-	VkBufferMemoryBarrier barrier = init::BufferMemoryBarrier();
-	barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-	barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-	barrier.dstAccessMask = dstAccess;
-	barrier.srcAccessMask = srcAccess;
-	barrier.offset = 0;
-	barrier.size = size;
-	VkBufferMemoryBarrier dynamicBarriers[Gfx::numFramesBuffered];
-	for(uint32 i = 0; i < numBuffers; ++i)
-	{
-		dynamicBarriers[i] = barrier;
-		dynamicBarriers[i].buffer = buffers[i].buffer;
-	}
-	vkCmdPipelineBarrier(commandBuffer->getHandle(), srcStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
+    PCmdBuffer commandBuffer = graphics->getQueueCommands(owner)->getCommands();
+    VkBufferMemoryBarrier barrier = init::BufferMemoryBarrier();
+    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    barrier.dstAccessMask = dstAccess;
+    barrier.srcAccessMask = srcAccess;
+    barrier.offset = 0;
+    barrier.size = size;
+    VkBufferMemoryBarrier dynamicBarriers[Gfx::numFramesBuffered];
+    for(uint32 i = 0; i < numBuffers; ++i)
+    {
+        dynamicBarriers[i] = barrier;
+        dynamicBarriers[i].buffer = buffers[i].buffer;
+    }
+    vkCmdPipelineBarrier(commandBuffer->getHandle(), srcStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
 }

 void *ShaderBuffer::lock(bool bWriteOnly)
 {
-	void *data = nullptr;
+    void *data = nullptr;

-	/*if (bVolatile)
-	{
-		if (lockMode == RLM_ReadOnly)
-		{
-			assert(0);
-		}
-		else
-		{
-			throw new std::logic_error("TODO implement volatile buffers");
-			//device->getRHIDevice()->getTemp
-		}
-	}*/
-	//assert(bStatic || bDynamic || bUAV);
+    /*if (bVolatile)
+    {
+        if (lockMode == RLM_ReadOnly)
+        {
+            assert(0);
+        }
+        else
+        {
+            throw new std::logic_error("TODO implement volatile buffers");
+            //device->getRHIDevice()->getTemp
+        }
+    }*/
+    //assert(bStatic || bDynamic || bUAV);

-	PendingBuffer pending;
-	pending.bWriteOnly = bWriteOnly;
-	pending.prevQueue = owner;
-	if (bWriteOnly)
-	{
-		//requestOwnershipTransfer(Gfx::QueueType::DEDICATED_TRANSFER);
-		PStagingBuffer stagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
-		data = stagingBuffer->getMappedPointer();
-		pending.stagingBuffer = stagingBuffer;
-	}
-	else
-	{
-		PCmdBuffer current = graphics->getQueueCommands(owner)->getCommands();
-		graphics->getQueueCommands(owner)->submitCommands();
-		current->waitForCommand();
+    PendingBuffer pending;
+    pending.bWriteOnly = bWriteOnly;
+    pending.prevQueue = owner;
+    if (bWriteOnly)
+    {
+        //requestOwnershipTransfer(Gfx::QueueType::DEDICATED_TRANSFER);
+        PStagingBuffer stagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
+        data = stagingBuffer->getMappedPointer();
+        pending.stagingBuffer = stagingBuffer;
+    }
+    else
+    {
+        PCmdBuffer current = graphics->getQueueCommands(owner)->getCommands();
+        graphics->getQueueCommands(owner)->submitCommands();
+        current->waitForCommand();

-		requestOwnershipTransfer(Gfx::QueueType::DEDICATED_TRANSFER);
-		VkCommandBuffer handle = graphics->getQueueCommands(owner)->getCommands()->getHandle();
+        requestOwnershipTransfer(Gfx::QueueType::DEDICATED_TRANSFER);
+        VkCommandBuffer handle = graphics->getQueueCommands(owner)->getCommands()->getHandle();

-		VkBufferMemoryBarrier barrier =
-			init::BufferMemoryBarrier();
-		barrier.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
-		barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
-		barrier.buffer = buffers[currentBuffer].buffer;
-		barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-		barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-		barrier.offset = 0;
-		barrier.size = size;
-		vkCmdPipelineBarrier(handle, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1, &barrier, 0, nullptr);
+        VkBufferMemoryBarrier barrier =
+            init::BufferMemoryBarrier();
+        barrier.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
+        barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+        barrier.buffer = buffers[currentBuffer].buffer;
+        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        barrier.offset = 0;
+        barrier.size = size;
+        vkCmdPipelineBarrier(handle, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1, &barrier, 0, nullptr);

-		PStagingBuffer stagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(size, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true);
+        PStagingBuffer stagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(size, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true);

-		VkBufferCopy regions;
-		regions.size = size;
-		regions.srcOffset = 0;
-		regions.dstOffset = 0;
+        VkBufferCopy regions;
+        regions.size = size;
+        regions.srcOffset = 0;
+        regions.dstOffset = 0;

-		vkCmdCopyBuffer(handle, buffers[currentBuffer].buffer, stagingBuffer->getHandle(), 1, &regions);
+        vkCmdCopyBuffer(handle, buffers[currentBuffer].buffer, stagingBuffer->getHandle(), 1, &regions);

-		graphics->getQueueCommands(owner)->submitCommands();
-		vkQueueWaitIdle(graphics->getQueueCommands(owner)->getQueue()->getHandle());
+        graphics->getQueueCommands(owner)->submitCommands();
+        vkQueueWaitIdle(graphics->getQueueCommands(owner)->getQueue()->getHandle());

-		stagingBuffer->flushMappedMemory();
-		pending.stagingBuffer = stagingBuffer;
+        stagingBuffer->flushMappedMemory();
+        pending.stagingBuffer = stagingBuffer;

-		data = stagingBuffer->getMappedPointer();
-	}
-	pendingBuffers[this] = pending;
+        data = stagingBuffer->getMappedPointer();
+    }
+    pendingBuffers[this] = pending;

-	assert(data);
-	return data;
+    assert(data);
+    return data;
 }

 void ShaderBuffer::unlock()
 {
-	auto found = pendingBuffers.find(this);
-	if (found != pendingBuffers.end())
-	{
-		PendingBuffer pending = found->value;
-		pending.stagingBuffer->flushMappedMemory();
-		pendingBuffers.erase(this);
-		if (pending.bWriteOnly)
-		{
-			PStagingBuffer stagingBuffer = pending.stagingBuffer;
-			PCmdBuffer cmdBuffer = graphics->getQueueCommands(owner)->getCommands();
-			VkCommandBuffer cmdHandle = cmdBuffer->getHandle();
+    auto found = pendingBuffers.find(this);
+    if (found != pendingBuffers.end())
+    {
+        PendingBuffer pending = found->value;
+        pending.stagingBuffer->flushMappedMemory();
+        pendingBuffers.erase(this);
+        if (pending.bWriteOnly)
+        {
+            PStagingBuffer stagingBuffer = pending.stagingBuffer;
+            PCmdBuffer cmdBuffer = graphics->getQueueCommands(owner)->getCommands();
+            VkCommandBuffer cmdHandle = cmdBuffer->getHandle();

-			VkBufferCopy region;
-			std::memset(&region, 0, sizeof(VkBufferCopy));
-			region.size = size;
-			vkCmdCopyBuffer(cmdHandle, stagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
-			graphics->getQueueCommands(owner)->submitCommands();
-		}
-		//requestOwnershipTransfer(pending.prevQueue);
-		graphics->getStagingManager()->releaseStagingBuffer(pending.stagingBuffer);
-	}
+            VkBufferCopy region;
+            std::memset(&region, 0, sizeof(VkBufferCopy));
+            region.size = size;
+            vkCmdCopyBuffer(cmdHandle, stagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
+            graphics->getQueueCommands(owner)->submitCommands();
+        }
+        //requestOwnershipTransfer(pending.prevQueue);
+        graphics->getStagingManager()->releaseStagingBuffer(pending.stagingBuffer);
+    }
 }

 UniformBuffer::UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &createInfo)
-	: Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.resourceData)
-	, Vulkan::ShaderBuffer(graphics, createInfo.resourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, currentOwner, createInfo.bDynamic)
-	, dedicatedStagingBuffer(nullptr)
+    : Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.resourceData)
+    , Vulkan::ShaderBuffer(graphics, createInfo.resourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, currentOwner, createInfo.bDynamic)
+    , dedicatedStagingBuffer(nullptr)
 {
-	if(createInfo.bDynamic)
-	{
-		dedicatedStagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(createInfo.resourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
-	}
-	if (createInfo.resourceData.data != nullptr)
-	{
-		void *data = lock();
-		std::memcpy(data, createInfo.resourceData.data, createInfo.resourceData.size);
-		unlock();
-	}
+    if(createInfo.bDynamic)
+    {
+        dedicatedStagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(createInfo.resourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
+    }
+    if (createInfo.resourceData.data != nullptr)
+    {
+        void *data = lock();
+        std::memcpy(data, createInfo.resourceData.data, createInfo.resourceData.size);
+        unlock();
+    }
 }

 UniformBuffer::~UniformBuffer()
@@ -290,52 +290,52 @@ UniformBuffer::~UniformBuffer()
 bool UniformBuffer::updateContents(const BulkResourceData &resourceData) 
 {
    if(!Gfx::UniformBuffer::updateContents(resourceData))
-	{
-		// no update was performed, skip
-		return false;
-	}
+    {
+        // no update was performed, skip
+        return false;
+    }
    void* data = lock();
    std::memcpy(data, resourceData.data, resourceData.size);
    unlock();
-	return true;
+    return true;
 }
 void* UniformBuffer::lock(bool bWriteOnly)
 {
-	if(dedicatedStagingBuffer != nullptr)
-	{
-		return dedicatedStagingBuffer->getMappedPointer();
-	}
-	return ShaderBuffer::lock(bWriteOnly);
+    if(dedicatedStagingBuffer != nullptr)
+    {
+        return dedicatedStagingBuffer->getMappedPointer();
+    }
+    return ShaderBuffer::lock(bWriteOnly);
 }

 void UniformBuffer::unlock()
 {
-	if(dedicatedStagingBuffer != nullptr)
-	{
-		dedicatedStagingBuffer->flushMappedMemory();
-		PCmdBuffer cmdBuffer = graphics->getQueueCommands(currentOwner)->getCommands();
-		VkCommandBuffer cmdHandle = cmdBuffer->getHandle();
+    if(dedicatedStagingBuffer != nullptr)
+    {
+        dedicatedStagingBuffer->flushMappedMemory();
+        PCmdBuffer cmdBuffer = graphics->getQueueCommands(currentOwner)->getCommands();
+        VkCommandBuffer cmdHandle = cmdBuffer->getHandle();

-		VkBufferCopy region;
-		std::memset(&region, 0, sizeof(VkBufferCopy));
-		region.size = ShaderBuffer::size;
-		vkCmdCopyBuffer(cmdHandle, dedicatedStagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
-		graphics->getQueueCommands(currentOwner)->submitCommands();
-	}
-	else
-	{
-		ShaderBuffer::unlock();
-	}
+        VkBufferCopy region;
+        std::memset(&region, 0, sizeof(VkBufferCopy));
+        region.size = ShaderBuffer::size;
+        vkCmdCopyBuffer(cmdHandle, dedicatedStagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
+        graphics->getQueueCommands(currentOwner)->submitCommands();
+    }
+    else
+    {
+        ShaderBuffer::unlock();
+    }
 }

 void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
-	Gfx::QueueOwnedResource::transferOwnership(newOwner);
+    Gfx::QueueOwnedResource::transferOwnership(newOwner);
 }

 void UniformBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-	Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
+    Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
 }

 void UniformBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
@@ -346,24 +346,24 @@ void UniformBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineSt

 VkAccessFlags UniformBuffer::getSourceAccessMask()
 {
-	return VK_ACCESS_MEMORY_WRITE_BIT;
+    return VK_ACCESS_MEMORY_WRITE_BIT;
 }

 VkAccessFlags UniformBuffer::getDestAccessMask()
 {
-	return VK_ACCESS_UNIFORM_READ_BIT;
+    return VK_ACCESS_UNIFORM_READ_BIT;
 }

 StructuredBuffer::StructuredBuffer(PGraphics graphics, const StructuredBufferCreateInfo &resourceData)
-	: Gfx::StructuredBuffer(graphics->getFamilyMapping(), resourceData.resourceData)
-	, Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, currentOwner, resourceData.bDynamic)
+    : Gfx::StructuredBuffer(graphics->getFamilyMapping(), resourceData.resourceData)
+    , Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, currentOwner, resourceData.bDynamic)
 {
-	if (resourceData.resourceData.data != nullptr)
-	{
-		void *data = lock();
-		std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
-		unlock();
-	}
+    if (resourceData.resourceData.data != nullptr)
+    {
+        void *data = lock();
+        std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
+        unlock();
+    }
 }

 StructuredBuffer::~StructuredBuffer()
@@ -373,49 +373,49 @@ StructuredBuffer::~StructuredBuffer()
 bool StructuredBuffer::updateContents(const BulkResourceData &resourceData) 
 {
    Gfx::StructuredBuffer::updateContents(resourceData);
-	//We always want to update, as the contents could be different on the GPU
+    //We always want to update, as the contents could be different on the GPU
    void* data = lock();
    std::memcpy(data, resourceData.data, resourceData.size);
    unlock();
-	return true;
+    return true;
 }
 void* StructuredBuffer::lock(bool bWriteOnly)
 {
-	if(dedicatedStagingBuffer != nullptr)
-	{
-		return dedicatedStagingBuffer->getMappedPointer();
-	}
-	return ShaderBuffer::lock(bWriteOnly);
+    if(dedicatedStagingBuffer != nullptr)
+    {
+        return dedicatedStagingBuffer->getMappedPointer();
+    }
+    return ShaderBuffer::lock(bWriteOnly);
 }

 void StructuredBuffer::unlock()
 {
-	if(dedicatedStagingBuffer != nullptr)
-	{
-		dedicatedStagingBuffer->flushMappedMemory();
-		PCmdBuffer cmdBuffer = graphics->getQueueCommands(currentOwner)->getCommands();
-		VkCommandBuffer cmdHandle = cmdBuffer->getHandle();
+    if(dedicatedStagingBuffer != nullptr)
+    {
+        dedicatedStagingBuffer->flushMappedMemory();
+        PCmdBuffer cmdBuffer = graphics->getQueueCommands(currentOwner)->getCommands();
+        VkCommandBuffer cmdHandle = cmdBuffer->getHandle();

-		VkBufferCopy region;
-		std::memset(&region, 0, sizeof(VkBufferCopy));
-		region.size = ShaderBuffer::size;
-		vkCmdCopyBuffer(cmdHandle, dedicatedStagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
-		graphics->getQueueCommands(currentOwner)->submitCommands();
-	}
-	else
-	{
-		ShaderBuffer::unlock();
-	}
+        VkBufferCopy region;
+        std::memset(&region, 0, sizeof(VkBufferCopy));
+        region.size = ShaderBuffer::size;
+        vkCmdCopyBuffer(cmdHandle, dedicatedStagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
+        graphics->getQueueCommands(currentOwner)->submitCommands();
+    }
+    else
+    {
+        ShaderBuffer::unlock();
+    }
 }

 void StructuredBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
-	Gfx::QueueOwnedResource::transferOwnership(newOwner);
+    Gfx::QueueOwnedResource::transferOwnership(newOwner);
 }

 void StructuredBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-	Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
+    Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
 }

 void StructuredBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
@@ -426,24 +426,24 @@ void StructuredBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelin

 VkAccessFlags StructuredBuffer::getSourceAccessMask()
 {
-	return VK_ACCESS_MEMORY_WRITE_BIT;
+    return VK_ACCESS_MEMORY_WRITE_BIT;
 }

 VkAccessFlags StructuredBuffer::getDestAccessMask()
 {
-	return VK_ACCESS_MEMORY_READ_BIT;
+    return VK_ACCESS_MEMORY_READ_BIT;
 }

 VertexBuffer::VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &resourceData)
-	: Gfx::VertexBuffer(graphics->getFamilyMapping(), resourceData.numVertices, resourceData.vertexSize, resourceData.resourceData.owner)
-	, Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, currentOwner)
+    : Gfx::VertexBuffer(graphics->getFamilyMapping(), resourceData.numVertices, resourceData.vertexSize, resourceData.resourceData.owner)
+    , Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, currentOwner)
 {
-	if (resourceData.resourceData.data != nullptr)
-	{
-		void *data = lock();
-		std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
-		unlock();
-	}
+    if (resourceData.resourceData.data != nullptr)
+    {
+        void *data = lock();
+        std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
+        unlock();
+    }
 }

 VertexBuffer::~VertexBuffer()
@@ -452,12 +452,12 @@ VertexBuffer::~VertexBuffer()

 void VertexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
-	Gfx::QueueOwnedResource::transferOwnership(newOwner);
+    Gfx::QueueOwnedResource::transferOwnership(newOwner);
 }

 void VertexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-	Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
+    Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
 }

 void VertexBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
@@ -468,24 +468,24 @@ void VertexBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineSta

 VkAccessFlags VertexBuffer::getSourceAccessMask()
 {
-	return VK_ACCESS_MEMORY_WRITE_BIT;
+    return VK_ACCESS_MEMORY_WRITE_BIT;
 }

 VkAccessFlags VertexBuffer::getDestAccessMask()
 {
-	return VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
+    return VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
 }

 IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &resourceData)
-	: Gfx::IndexBuffer(graphics->getFamilyMapping(), resourceData.resourceData.size, resourceData.indexType, resourceData.resourceData.owner)
-	, Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, currentOwner)
+    : Gfx::IndexBuffer(graphics->getFamilyMapping(), resourceData.resourceData.size, resourceData.indexType, resourceData.resourceData.owner)
+    , Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, currentOwner)
 {
-	if (resourceData.resourceData.data != nullptr)
-	{
-		void *data = lock();
-		std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
-		unlock();
-	}
+    if (resourceData.resourceData.data != nullptr)
+    {
+        void *data = lock();
+        std::memcpy(data, resourceData.resourceData.data, resourceData.resourceData.size);
+        unlock();
+    }
 }

 IndexBuffer::~IndexBuffer()
@@ -494,12 +494,12 @@ IndexBuffer::~IndexBuffer()

 void IndexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
-	Gfx::QueueOwnedResource::transferOwnership(newOwner);
+    Gfx::QueueOwnedResource::transferOwnership(newOwner);
 }

 void IndexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-	Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
+    Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
 }

 void IndexBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
@@ -510,10 +510,10 @@ void IndexBuffer::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStag

 VkAccessFlags IndexBuffer::getSourceAccessMask()
 {
-	return VK_ACCESS_MEMORY_WRITE_BIT;
+    return VK_ACCESS_MEMORY_WRITE_BIT;
 }

 VkAccessFlags IndexBuffer::getDestAccessMask()
 {
-	return VK_ACCESS_INDEX_READ_BIT;
+    return VK_ACCESS_INDEX_READ_BIT;
 }