public void SetLayout(
CommandBuffer cmdbuffer,
VkAccessFlags srcAccessMask,
VkAccessFlags dstAccessMask,
VkImageLayout oldImageLayout,
VkImageLayout newImageLayout,
VkImageSubresourceRange subresourceRange,
VkPipelineStageFlags srcStageMask = VkPipelineStageFlags.AllCommands,
VkPipelineStageFlags dstStageMask = VkPipelineStageFlags.AllCommands,
uint srcQueueFamilyIndex = Vk.QueueFamilyIgnored,
uint dstQueueFamilyIndex = Vk.QueueFamilyIgnored)
{
VkImageMemoryBarrier imageMemoryBarrier = VkImageMemoryBarrier.New();
imageMemoryBarrier.srcQueueFamilyIndex = srcQueueFamilyIndex;
imageMemoryBarrier.dstQueueFamilyIndex = dstQueueFamilyIndex;
imageMemoryBarrier.oldLayout = oldImageLayout;
imageMemoryBarrier.newLayout = newImageLayout;
imageMemoryBarrier.image = handle;
imageMemoryBarrier.subresourceRange = subresourceRange;
imageMemoryBarrier.srcAccessMask = srcAccessMask;
imageMemoryBarrier.dstAccessMask = dstAccessMask;
Vk.vkCmdPipelineBarrier(
cmdbuffer.Handle,
srcStageMask,
dstStageMask,
0,
0, IntPtr.Zero,
0, IntPtr.Zero,
1, ref imageMemoryBarrier);
}
public void CmdWaitEvents(IReadOnlyList <IVkEvent> events, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, IReadOnlyList <VkMemoryBarrier> memoryBarriers, IReadOnlyList <VkBufferMemoryBarrier> bufferMemoryBarriers, IReadOnlyList <VkImageMemoryBarrier> imageMemoryBarriers)
{
var unmanagedSize =
events.SizeOfMarshalDirect() +
memoryBarriers.SizeOfMarshalDirect() +
bufferMemoryBarriers.SizeOfMarshalDirect() +
imageMemoryBarriers.SizeOfMarshalDirect();
var unmanagedArray = new byte[unmanagedSize];
fixed(byte *unmanagedStart = unmanagedArray)
{
var unmanaged = unmanagedStart;
var _commandBuffer = Handle;
var _eventCount = events?.Count ?? 0;
var _pEvents = events.MarshalDirect(ref unmanaged);
var _srcStageMask = srcStageMask;
var _dstStageMask = dstStageMask;
var _memoryBarrierCount = memoryBarriers?.Count ?? 0;
var _pMemoryBarriers = memoryBarriers.MarshalDirect(ref unmanaged);
var _bufferMemoryBarrierCount = bufferMemoryBarriers?.Count ?? 0;
var _pBufferMemoryBarriers = bufferMemoryBarriers.MarshalDirect(ref unmanaged);
var _imageMemoryBarrierCount = imageMemoryBarriers?.Count ?? 0;
var _pImageMemoryBarriers = imageMemoryBarriers.MarshalDirect(ref unmanaged);
Direct.CmdWaitEvents(_commandBuffer, _eventCount, _pEvents, _srcStageMask, _dstStageMask, _memoryBarrierCount, _pMemoryBarriers, _bufferMemoryBarrierCount, _pBufferMemoryBarriers, _imageMemoryBarrierCount, _pImageMemoryBarriers);
}
}
public void CmdPipelineBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, IReadOnlyList <VkMemoryBarrier> memoryBarriers, IReadOnlyList <VkBufferMemoryBarrier> bufferMemoryBarriers, IReadOnlyList <VkImageMemoryBarrier> imageMemoryBarriers)
{
var unmanagedSize =
memoryBarriers.SizeOfMarshalDirect() +
bufferMemoryBarriers.SizeOfMarshalDirect() +
imageMemoryBarriers.SizeOfMarshalDirect();
var unmanagedArray = new byte[unmanagedSize];
fixed(byte *unmanagedStart = unmanagedArray)
{
var unmanaged = unmanagedStart;
var _commandBuffer = Handle;
var _srcStageMask = srcStageMask;
var _dstStageMask = dstStageMask;
var _dependencyFlags = dependencyFlags;
var _memoryBarrierCount = memoryBarriers?.Count ?? 0;
var _pMemoryBarriers = memoryBarriers.MarshalDirect(ref unmanaged);
var _bufferMemoryBarrierCount = bufferMemoryBarriers?.Count ?? 0;
var _pBufferMemoryBarriers = bufferMemoryBarriers.MarshalDirect(ref unmanaged);
var _imageMemoryBarrierCount = imageMemoryBarriers?.Count ?? 0;
var _pImageMemoryBarriers = imageMemoryBarriers.MarshalDirect(ref unmanaged);
Direct.CmdPipelineBarrier(_commandBuffer, _srcStageMask, _dstStageMask, _dependencyFlags, _memoryBarrierCount, _pMemoryBarriers, _bufferMemoryBarrierCount, _pBufferMemoryBarriers, _imageMemoryBarrierCount, _pImageMemoryBarriers);
}
}
public void CmdWriteTimestamp(
[FromProperty("this")] GenCommandBuffer commandBuffer,
VkPipelineStageFlags pipelineStage,
GenQueryPool queryPool,
int query)
{
}
public void Submit(VkSemaphore waitSemaphore, VkPipelineStageFlags waitDstStageMask,
VkCommandBuffer commandBuffer, VkSemaphore signalSemaphore, VkFence fence = default)
{
VkCommandBuffer commandBufferHandle = commandBuffer;
var nativeSubmit = new VkSubmitInfo
{
sType = VkStructureType.SubmitInfo
};
if (waitSemaphore != default)
{
nativeSubmit.waitSemaphoreCount = 1;
nativeSubmit.pWaitSemaphores = &waitSemaphore;
nativeSubmit.pWaitDstStageMask = &waitDstStageMask;
}
if (commandBuffer != null)
{
nativeSubmit.commandBufferCount = 1;
nativeSubmit.pCommandBuffers = &commandBufferHandle;
}
if (signalSemaphore != default)
{
nativeSubmit.signalSemaphoreCount = 1;
nativeSubmit.pSignalSemaphores = &signalSemaphore;
}
VulkanUtil.CheckResult(vkQueueSubmit(this, 1, &nativeSubmit, fence));
}
public void CmdResetEvent(IVkEvent eventObj, VkPipelineStageFlags stageMask)
{
var _commandBuffer = Handle;
var _eventObj = eventObj?.Handle ?? VkEvent.HandleType.Null;
var _stageMask = stageMask;
Direct.CmdResetEvent(_commandBuffer, _eventObj, _stageMask);
}
public void CmdWriteTimestamp(VkPipelineStageFlags pipelineStage, IVkQueryPool queryPool, int query)
{
var _commandBuffer = Handle;
var _pipelineStage = pipelineStage;
var _queryPool = queryPool?.Handle ?? VkQueryPool.HandleType.Null;
var _query = query;
Direct.CmdWriteTimestamp(_commandBuffer, _pipelineStage, _queryPool, _query);
}
public void SetMemoryBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkDependencyFlags dependencyFlags = VkDependencyFlags.ByRegion)
{
VkMemoryBarrier memoryBarrier = VkMemoryBarrier.New();
memoryBarrier.srcAccessMask = srcAccessMask;
memoryBarrier.dstAccessMask = dstAccessMask;
Vk.vkCmdPipelineBarrier(Handle, srcStageMask, dstStageMask,
dependencyFlags, 1, ref memoryBarrier, 0, IntPtr.Zero, 0, IntPtr.Zero);
}
protected virtual void Draw(Timer timer)
{
// Acquire an index of drawing image for this frame.
uint nextImageIndex;
VkResult result = vkAcquireNextImageKHR(Context.Device, Swapchain, ulong.MaxValue, ImageAvailableSemaphore, VkFence.Null, out nextImageIndex);
result.CheckResult();
// Use a fence to wait until the command buffer has finished execution before using it again
VkFence fence = SubmitFences[nextImageIndex];
result = vkWaitForFences(Context.Device, 1, &fence, false, ulong.MaxValue);
result.CheckResult();
result = vkResetFences(Context.Device, 1, &fence);
result.CheckResult();
VkSemaphore signalSemaphore = RenderingFinishedSemaphore;
VkSemaphore waitSemaphore = ImageAvailableSemaphore;
VkPipelineStageFlags waitStages = VkPipelineStageFlags.ColorAttachmentOutput;
VkCommandBuffer commandBuffer = CommandBuffers[nextImageIndex];
VkSubmitInfo submitInfo = new VkSubmitInfo()
{
sType = VkStructureType.SubmitInfo,
waitSemaphoreCount = 1,
pWaitSemaphores = &waitSemaphore,
pWaitDstStageMask = &waitStages,
commandBufferCount = 1,
pCommandBuffers = &commandBuffer,
signalSemaphoreCount = 1,
pSignalSemaphores = &signalSemaphore,
};
result = vkQueueSubmit(Context.GraphicsQueue, 1, &submitInfo, SubmitFences[nextImageIndex]);
result.CheckResult();
// Present the color output to screen.
VkSemaphore waitSemaphoreHandle = RenderingFinishedSemaphore;
VkSwapchainKHR swapchainHandle = Swapchain;
var nativePresentInfo = new VkPresentInfoKHR
{
sType = VkStructureType.PresentInfoKHR,
pNext = null,
waitSemaphoreCount = 1,
pWaitSemaphores = &waitSemaphoreHandle,
swapchainCount = 1,
pSwapchains = &swapchainHandle,
pImageIndices = &nextImageIndex
};
result = vkQueuePresentKHR(Context.PresentQueue, &nativePresentInfo);
result.CheckResult();
}
public void CmdPipelineBarrier(
[FromProperty("this")] GenCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
[CountFor("memoryBarriers")] int memoryBarrierCount,
[IsArray] GenMemoryBarrier* pMemoryBarriers,
[CountFor("bufferMemoryBarriers")] int bufferMemoryBarrierCount,
[IsArray] GenBufferMemoryBarrier* pBufferMemoryBarriers,
[CountFor("imageMemoryBarriers")] int imageMemoryBarrierCount,
[IsArray] GenImageMemoryBarrier* pImageMemoryBarriers)
{ }
public static extern void CmdPipelineBarrier(
VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint memoryBarrierCount,
IntPtr pMemoryBarriers,
uint bufferMemoryBarrierCount,
IntPtr pBufferMemoryBarriers,
uint imageMemoryBarrierCount,
IntPtr pImageMemoryBarriers
);
private void barrier(VkPipelineStageFlags src_stages, VkAccessFlags src_access, VkPipelineStageFlags dst_stages,
VkAccessFlags dst_access)
{
VkMemoryBarrier barrier = new()
{
sType = VkStructureType.MemoryBarrier,
};
barrier.srcAccessMask = src_access;
barrier.dstAccessMask = dst_access;
vkCmdPipelineBarrier(handle, src_stages, dst_stages, 0, 1, &barrier, 0, null, 0, null);
}
private void fixup_src_stage(ref VkPipelineStageFlags src_stages, bool fixup)
{
// ALL_GRAPHICS_BIT waits for vertex as well which causes performance issues on some drivers.
// It shouldn't matter, but hey.
//
// We aren't using vertex with side-effects on relevant hardware so dropping VERTEX_SHADER_BIT is fine.
if ((src_stages & VkPipelineStageFlags.AllGraphics) != 0 && fixup)
{
src_stages &= ~VkPipelineStageFlags.AllGraphics;
src_stages |= VkPipelineStageFlags.ColorAttachmentOutput | VkPipelineStageFlags.FragmentShader | VkPipelineStageFlags.LateFragmentTests;
}
}
public static extern void CmdWaitEvents(
VkCommandBuffer commandBuffer,
uint eventCount,
IntPtr pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
uint memoryBarrierCount,
IntPtr pMemoryBarriers,
uint bufferMemoryBarrierCount,
IntPtr pBufferMemoryBarriers,
uint imageMemoryBarrierCount,
IntPtr pImageMemoryBarriers
);
public void CmdPipelineBarrier(
[FromProperty("this")] GenCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
[CountFor("memoryBarriers")] int memoryBarrierCount,
[IsArray] GenMemoryBarrier *pMemoryBarriers,
[CountFor("bufferMemoryBarriers")] int bufferMemoryBarrierCount,
[IsArray] GenBufferMemoryBarrier *pBufferMemoryBarriers,
[CountFor("imageMemoryBarriers")] int imageMemoryBarrierCount,
[IsArray] GenImageMemoryBarrier *pImageMemoryBarriers)
{
}
public void CmdWaitEvents(
[FromProperty("this")] GenCommandBuffer commandBuffer,
[CountFor("events")] int eventCount,
[IsArray] GenEvent* pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
[CountFor("memoryBarriers")] int memoryBarrierCount,
[IsArray] GenMemoryBarrier* pMemoryBarriers,
[CountFor("bufferMemoryBarriers")] int bufferMemoryBarrierCount,
[IsArray] GenBufferMemoryBarrier* pBufferMemoryBarriers,
[CountFor("imageMemoryBarriers")] int imageMemoryBarrierCount,
[IsArray] GenImageMemoryBarrier* pImageMemoryBarriers)
{ }
internal unsafe void SubmitCommand(
VkQueue queue,
List <Semaphore> signalSemaphores,
List <Semaphore> waitSemaphores,
VkPipelineStageFlags waitStageMask = VkPipelineStageFlags.TopOfPipe
) => SubmitCommands(
new List <CommandBuffer> {
this
},
queue,
signalSemaphores,
waitSemaphores,
waitStageMask
);
public void CmdWaitEvents(
[FromProperty("this")] GenCommandBuffer commandBuffer,
[CountFor("events")] int eventCount,
[IsArray] GenEvent *pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
[CountFor("memoryBarriers")] int memoryBarrierCount,
[IsArray] GenMemoryBarrier *pMemoryBarriers,
[CountFor("bufferMemoryBarriers")] int bufferMemoryBarrierCount,
[IsArray] GenBufferMemoryBarrier *pBufferMemoryBarriers,
[CountFor("imageMemoryBarriers")] int imageMemoryBarrierCount,
[IsArray] GenImageMemoryBarrier *pImageMemoryBarriers)
{
}
public void AddDependency(uint srcSubpass, uint dstSubpass,
VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask,
VkDependencyFlags dependencyFlags = VkDependencyFlags.ByRegion)
{
dependencies.Add(new VkSubpassDependency {
srcSubpass = srcSubpass,
dstSubpass = dstSubpass,
srcStageMask = srcStageMask,
dstStageMask = dstStageMask,
srcAccessMask = srcAccessMask,
dstAccessMask = dstAccessMask,
dependencyFlags = dependencyFlags
});
}
public void SetLayout(
CommandBuffer cmdbuffer,
VkImageAspectFlags aspectMask,
VkImageLayout oldImageLayout,
VkImageLayout newImageLayout,
VkPipelineStageFlags srcStageMask = VkPipelineStageFlags.AllCommands,
VkPipelineStageFlags dstStageMask = VkPipelineStageFlags.AllCommands)
{
VkImageSubresourceRange subresourceRange = new VkImageSubresourceRange {
aspectMask = aspectMask,
baseMipLevel = 0,
levelCount = CreateInfo.mipLevels,
layerCount = CreateInfo.arrayLayers,
};
SetLayout(cmdbuffer, oldImageLayout, newImageLayout, subresourceRange, srcStageMask, dstStageMask);
}
// Fixed sub resource on first mip level and layer
public static void setImageLayout(
VkCommandBuffer cmdbuffer,
VkImage image,
VkImageAspectFlags aspectMask,
VkImageLayout oldImageLayout,
VkImageLayout newImageLayout,
VkPipelineStageFlags srcStageMask = VkPipelineStageFlags.AllCommands,
VkPipelineStageFlags dstStageMask = VkPipelineStageFlags.AllCommands)
{
VkImageSubresourceRange subresourceRange = new VkImageSubresourceRange();
subresourceRange.aspectMask = aspectMask;
subresourceRange.baseMipLevel = 0;
subresourceRange.levelCount = 1;
subresourceRange.layerCount = 1;
setImageLayout(cmdbuffer, image, aspectMask, oldImageLayout, newImageLayout, subresourceRange);
}
public override void ExecuteCommands(CommandList cl)
{
VkCommandList vkCL = Util.AssertSubtype <CommandList, VkCommandList>(cl);
VkSubmitInfo si = VkSubmitInfo.New();
si.commandBufferCount = 1;
VkCommandBuffer vkCB = vkCL.CommandBuffer;
si.pCommandBuffers = &vkCB;
VkPipelineStageFlags waitDstStageMask = VkPipelineStageFlags.ColorAttachmentOutput;
si.pWaitDstStageMask = &waitDstStageMask;
vkQueueSubmit(_graphicsQueue, 1, ref si, VkFence.Null);
lock (_disposablesLock)
{
vkCL.CollectDisposables(_imagesToDestroy, _memoriesToFree);
}
}
unsafe public VkResult submit(VkCommandBuffer cmd, VkSemaphore waitSemaphore, VkSemaphore signalSemaphore, VkFence waitFence)
{
VkSubmitInfo submitInfo = VkSubmitInfo.New();
VkPipelineStageFlags waitStageMask = VkPipelineStageFlags.ColorAttachmentOutput;
submitInfo.pWaitDstStageMask = &waitStageMask;
var pcs = waitSemaphore;
submitInfo.pWaitSemaphores = &pcs;
submitInfo.waitSemaphoreCount = 1;
var rcs = signalSemaphore;
submitInfo.pSignalSemaphores = &rcs;
submitInfo.signalSemaphoreCount = 1;
var cmdBuf = &cmd;
submitInfo.pCommandBuffers = cmdBuf;
submitInfo.commandBufferCount = 1;
// Submit to the graphics queue passing a wait fence
return(vkQueueSubmit(this, 1, ref submitInfo, waitFence));
}
public void Submit()
{
VkSemaphore signalSemaphore = NativeDevice.RenderFinishedSemaphore;
VkSemaphore waitSemaphore = NativeDevice.ImageAvailableSemaphore;
VkPipelineStageFlags waitStages = VkPipelineStageFlags.ColorAttachmentOutput;
VkCommandBuffer commandBuffer = CommandBuffer;
VkSubmitInfo submitInfo = new VkSubmitInfo()
{
sType = VkStructureType.SubmitInfo,
waitSemaphoreCount = 1,
pWaitSemaphores = &waitSemaphore,
pWaitDstStageMask = &waitStages,
commandBufferCount = 1,
pCommandBuffers = &commandBuffer,
signalSemaphoreCount = 1,
pSignalSemaphores = &signalSemaphore,
};
vkQueueSubmit(NativeDevice.NativeCommandQueue, 1, &submitInfo, VkFence.Null);
}
public void SetLayout(
CommandBuffer cmdbuffer,
VkImageAspectFlags aspectMask,
VkAccessFlags srcAccessMask,
VkAccessFlags dstAccessMask,
VkImageLayout oldImageLayout,
VkImageLayout newImageLayout,
VkPipelineStageFlags srcStageMask = VkPipelineStageFlags.AllCommands,
VkPipelineStageFlags dstStageMask = VkPipelineStageFlags.AllCommands,
uint srcQueueFamilyIndex = Vk.QueueFamilyIgnored,
uint dstQueueFamilyIndex = Vk.QueueFamilyIgnored)
{
VkImageSubresourceRange subresourceRange = new VkImageSubresourceRange {
aspectMask = aspectMask,
baseMipLevel = 0,
levelCount = CreateInfo.mipLevels,
layerCount = CreateInfo.arrayLayers,
};
SetLayout(cmdbuffer, srcAccessMask, dstAccessMask, oldImageLayout, newImageLayout, subresourceRange, srcStageMask, dstStageMask,
srcQueueFamilyIndex, dstQueueFamilyIndex);
}
public void End(PrimaryCommandBuffer cmd, VkPipelineStageFlags stageFlags = VkPipelineStageFlags.BottomOfPipe)
{
vkCmdWriteTimestamp(cmd.Handle, stageFlags, handle, 1);
}
public static void TransitionImageLayout(
VkCommandBuffer cb,
VkImage image,
uint baseMipLevel,
uint levelCount,
uint baseArrayLayer,
uint layerCount,
VkImageAspectFlags aspectMask,
VkImageLayout oldLayout,
VkImageLayout newLayout)
{
Debug.Assert(oldLayout != newLayout);
VkImageMemoryBarrier barrier = VkImageMemoryBarrier.New();
barrier.oldLayout = oldLayout;
barrier.newLayout = newLayout;
barrier.srcQueueFamilyIndex = QueueFamilyIgnored;
barrier.dstQueueFamilyIndex = QueueFamilyIgnored;
barrier.image = image;
barrier.subresourceRange.aspectMask = aspectMask;
barrier.subresourceRange.baseMipLevel = baseMipLevel;
barrier.subresourceRange.levelCount = levelCount;
barrier.subresourceRange.baseArrayLayer = baseArrayLayer;
barrier.subresourceRange.layerCount = layerCount;
VkPipelineStageFlags srcStageFlags = VkPipelineStageFlags.None;
VkPipelineStageFlags dstStageFlags = VkPipelineStageFlags.None;
if ((oldLayout == VkImageLayout.Undefined || oldLayout == VkImageLayout.Preinitialized) && newLayout == VkImageLayout.TransferDstOptimal)
{
barrier.srcAccessMask = VkAccessFlags.None;
barrier.dstAccessMask = VkAccessFlags.TransferWrite;
srcStageFlags = VkPipelineStageFlags.TopOfPipe;
dstStageFlags = VkPipelineStageFlags.Transfer;
}
else if (oldLayout == VkImageLayout.ShaderReadOnlyOptimal && newLayout == VkImageLayout.TransferSrcOptimal)
{
barrier.srcAccessMask = VkAccessFlags.ShaderRead;
barrier.dstAccessMask = VkAccessFlags.TransferRead;
srcStageFlags = VkPipelineStageFlags.FragmentShader;
dstStageFlags = VkPipelineStageFlags.Transfer;
}
else if (oldLayout == VkImageLayout.ShaderReadOnlyOptimal && newLayout == VkImageLayout.TransferDstOptimal)
{
barrier.srcAccessMask = VkAccessFlags.ShaderRead;
barrier.dstAccessMask = VkAccessFlags.TransferWrite;
srcStageFlags = VkPipelineStageFlags.FragmentShader;
dstStageFlags = VkPipelineStageFlags.Transfer;
}
else if (oldLayout == VkImageLayout.Preinitialized && newLayout == VkImageLayout.TransferSrcOptimal)
{
barrier.srcAccessMask = VkAccessFlags.None;
barrier.dstAccessMask = VkAccessFlags.TransferRead;
srcStageFlags = VkPipelineStageFlags.TopOfPipe;
dstStageFlags = VkPipelineStageFlags.Transfer;
}
else if (oldLayout == VkImageLayout.TransferSrcOptimal && newLayout == VkImageLayout.ShaderReadOnlyOptimal)
{
barrier.srcAccessMask = VkAccessFlags.TransferRead;
barrier.dstAccessMask = VkAccessFlags.ShaderRead;
srcStageFlags = VkPipelineStageFlags.Transfer;
dstStageFlags = VkPipelineStageFlags.FragmentShader;
}
else if (oldLayout == VkImageLayout.TransferDstOptimal && newLayout == VkImageLayout.ShaderReadOnlyOptimal)
{
barrier.srcAccessMask = VkAccessFlags.TransferWrite;
barrier.dstAccessMask = VkAccessFlags.ShaderRead;
srcStageFlags = VkPipelineStageFlags.Transfer;
dstStageFlags = VkPipelineStageFlags.FragmentShader;
}
else if (oldLayout == VkImageLayout.TransferSrcOptimal && newLayout == VkImageLayout.TransferDstOptimal)
{
barrier.srcAccessMask = VkAccessFlags.TransferRead;
barrier.dstAccessMask = VkAccessFlags.TransferWrite;
srcStageFlags = VkPipelineStageFlags.Transfer;
dstStageFlags = VkPipelineStageFlags.Transfer;
}
else if (oldLayout == VkImageLayout.TransferDstOptimal && newLayout == VkImageLayout.TransferSrcOptimal)
{
barrier.srcAccessMask = VkAccessFlags.TransferWrite;
barrier.dstAccessMask = VkAccessFlags.TransferRead;
srcStageFlags = VkPipelineStageFlags.Transfer;
dstStageFlags = VkPipelineStageFlags.Transfer;
}
else if (oldLayout == VkImageLayout.ColorAttachmentOptimal && newLayout == VkImageLayout.TransferSrcOptimal)
{
barrier.srcAccessMask = VkAccessFlags.ColorAttachmentWrite;
barrier.dstAccessMask = VkAccessFlags.TransferRead;
srcStageFlags = VkPipelineStageFlags.ColorAttachmentOutput;
dstStageFlags = VkPipelineStageFlags.Transfer;
}
else if (oldLayout == VkImageLayout.ColorAttachmentOptimal && newLayout == VkImageLayout.TransferDstOptimal)
{
barrier.srcAccessMask = VkAccessFlags.ColorAttachmentWrite;
barrier.dstAccessMask = VkAccessFlags.TransferWrite;
srcStageFlags = VkPipelineStageFlags.ColorAttachmentOutput;
dstStageFlags = VkPipelineStageFlags.Transfer;
}
else if (oldLayout == VkImageLayout.ColorAttachmentOptimal && newLayout == VkImageLayout.ShaderReadOnlyOptimal)
{
barrier.srcAccessMask = VkAccessFlags.ColorAttachmentWrite;
barrier.dstAccessMask = VkAccessFlags.ShaderRead;
srcStageFlags = VkPipelineStageFlags.ColorAttachmentOutput;
dstStageFlags = VkPipelineStageFlags.FragmentShader;
}
else if (oldLayout == VkImageLayout.DepthStencilAttachmentOptimal && newLayout == VkImageLayout.ShaderReadOnlyOptimal)
{
barrier.srcAccessMask = VkAccessFlags.DepthStencilAttachmentWrite;
barrier.dstAccessMask = VkAccessFlags.ShaderRead;
srcStageFlags = VkPipelineStageFlags.LateFragmentTests;
dstStageFlags = VkPipelineStageFlags.FragmentShader;
}
else if (oldLayout == VkImageLayout.ColorAttachmentOptimal && newLayout == VkImageLayout.PresentSrcKHR)
{
barrier.srcAccessMask = VkAccessFlags.ColorAttachmentWrite;
barrier.dstAccessMask = VkAccessFlags.MemoryRead;
srcStageFlags = VkPipelineStageFlags.ColorAttachmentOutput;
dstStageFlags = VkPipelineStageFlags.BottomOfPipe;
}
else if (oldLayout == VkImageLayout.TransferDstOptimal && newLayout == VkImageLayout.ColorAttachmentOptimal)
{
barrier.srcAccessMask = VkAccessFlags.TransferWrite;
barrier.dstAccessMask = VkAccessFlags.ColorAttachmentWrite;
srcStageFlags = VkPipelineStageFlags.Transfer;
dstStageFlags = VkPipelineStageFlags.ColorAttachmentOutput;
}
else if (oldLayout == VkImageLayout.TransferDstOptimal && newLayout == VkImageLayout.DepthStencilAttachmentOptimal)
{
barrier.srcAccessMask = VkAccessFlags.TransferWrite;
barrier.dstAccessMask = VkAccessFlags.DepthStencilAttachmentWrite;
srcStageFlags = VkPipelineStageFlags.Transfer;
dstStageFlags = VkPipelineStageFlags.LateFragmentTests;
}
else
{
Debug.Fail("Invalid image layout transition.");
}
vkCmdPipelineBarrier(
cb,
srcStageFlags,
dstStageFlags,
VkDependencyFlags.None,
0, null,
0, null,
1, &barrier);
}
// Create an image memory barrier for changing the layout of
// an image and put it into an active command buffer
// See chapter 11.4 "Image Layout" for details
public static void setImageLayout(
VkCommandBuffer cmdbuffer,
VkImage image,
VkImageAspectFlags aspectMask,
VkImageLayout oldImageLayout,
VkImageLayout newImageLayout,
VkImageSubresourceRange subresourceRange,
VkPipelineStageFlags srcStageMask = VkPipelineStageFlags.AllCommands,
VkPipelineStageFlags dstStageMask = VkPipelineStageFlags.AllCommands)
{
// Create an image barrier object
VkImageMemoryBarrier imageMemoryBarrier = Initializers.imageMemoryBarrier();
imageMemoryBarrier.oldLayout = oldImageLayout;
imageMemoryBarrier.newLayout = newImageLayout;
imageMemoryBarrier.image = image;
imageMemoryBarrier.subresourceRange = subresourceRange;
// Source layouts (old)
// Source access mask controls actions that have to be finished on the old layout
// before it will be transitioned to the new layout
switch (oldImageLayout)
{
case VkImageLayout.Undefined:
// Image layout is undefined (or does not matter)
// Only valid as initial layout
// No flags required, listed only for completeness
imageMemoryBarrier.srcAccessMask = 0;
break;
case VkImageLayout.Preinitialized:
// Image is preinitialized
// Only valid as initial layout for linear images, preserves memory contents
// Make sure host writes have been finished
imageMemoryBarrier.srcAccessMask = VkAccessFlags.HostWrite;
break;
case VkImageLayout.ColorAttachmentOptimal:
// Image is a color attachment
// Make sure any writes to the color buffer have been finished
imageMemoryBarrier.srcAccessMask = VkAccessFlags.ColorAttachmentWrite;
break;
case VkImageLayout.DepthStencilAttachmentOptimal:
// Image is a depth/stencil attachment
// Make sure any writes to the depth/stencil buffer have been finished
imageMemoryBarrier.srcAccessMask = VkAccessFlags.DepthStencilAttachmentWrite;
break;
case VkImageLayout.TransferSrcOptimal:
// Image is a transfer source
// Make sure any reads from the image have been finished
imageMemoryBarrier.srcAccessMask = VkAccessFlags.TransferRead;
break;
case VkImageLayout.TransferDstOptimal:
// Image is a transfer destination
// Make sure any writes to the image have been finished
imageMemoryBarrier.srcAccessMask = VkAccessFlags.TransferWrite;
break;
case VkImageLayout.ShaderReadOnlyOptimal:
// Image is read by a shader
// Make sure any shader reads from the image have been finished
imageMemoryBarrier.srcAccessMask = VkAccessFlags.ShaderRead;
break;
}
// Target layouts (new)
// Destination access mask controls the dependency for the new image layout
switch (newImageLayout)
{
case VkImageLayout.TransferDstOptimal:
// Image will be used as a transfer destination
// Make sure any writes to the image have been finished
imageMemoryBarrier.dstAccessMask = VkAccessFlags.TransferWrite;
break;
case VkImageLayout.TransferSrcOptimal:
// Image will be used as a transfer source
// Make sure any reads from and writes to the image have been finished
imageMemoryBarrier.srcAccessMask = imageMemoryBarrier.srcAccessMask | VkAccessFlags.TransferRead;
imageMemoryBarrier.dstAccessMask = VkAccessFlags.TransferRead;
break;
case VkImageLayout.ColorAttachmentOptimal:
// Image will be used as a color attachment
// Make sure any writes to the color buffer have been finished
imageMemoryBarrier.srcAccessMask = VkAccessFlags.TransferRead;
imageMemoryBarrier.dstAccessMask = VkAccessFlags.ColorAttachmentWrite;
break;
case VkImageLayout.DepthStencilAttachmentOptimal:
// Image layout will be used as a depth/stencil attachment
// Make sure any writes to depth/stencil buffer have been finished
imageMemoryBarrier.dstAccessMask = imageMemoryBarrier.dstAccessMask | VkAccessFlags.DepthStencilAttachmentWrite;
break;
case VkImageLayout.ShaderReadOnlyOptimal:
// Image will be read in a shader (sampler, input attachment)
// Make sure any writes to the image have been finished
if (imageMemoryBarrier.srcAccessMask == 0)
{
imageMemoryBarrier.srcAccessMask = VkAccessFlags.HostWrite | VkAccessFlags.TransferWrite;
}
imageMemoryBarrier.dstAccessMask = VkAccessFlags.ShaderRead;
break;
}
// Put barrier inside setup command buffer
vkCmdPipelineBarrier(
cmdbuffer,
srcStageMask,
dstStageMask,
0,
0, null,
0, null,
1, &imageMemoryBarrier);
}
public void Write(PrimaryCommandBuffer cmd, uint query, VkPipelineStageFlags stageFlags = VkPipelineStageFlags.BottomOfPipe)
{
vkCmdWriteTimestamp(cmd.Handle, stageFlags, handle, query);
}
internal extern static void vkCmdWriteTimestamp(IntPtr commandBuffer, VkPipelineStageFlags pipelineStage, UInt64 queryPool, UInt32 query);
public void CmdResetEvent(IVkEvent eventObj, VkPipelineStageFlags stageMask)
{
var _commandBuffer = Handle;
var _eventObj = eventObj?.Handle ?? VkEvent.HandleType.Null;
var _stageMask = stageMask;
Direct.CmdResetEvent(_commandBuffer, _eventObj, _stageMask);
}
internal extern static unsafe void vkCmdWaitEvents(IntPtr commandBuffer, UInt32 eventCount, UInt64 *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, UInt32 memoryBarrierCount, VkMemoryBarrier *pMemoryBarriers, UInt32 bufferMemoryBarrierCount, VkBufferMemoryBarrier *pBufferMemoryBarriers, UInt32 imageMemoryBarrierCount, VkImageMemoryBarrier *pImageMemoryBarriers);
internal extern static unsafe void vkCmdPipelineBarrier(IntPtr commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, UInt32 memoryBarrierCount, VkMemoryBarrier *pMemoryBarriers, UInt32 bufferMemoryBarrierCount, VkBufferMemoryBarrier *pBufferMemoryBarriers, UInt32 imageMemoryBarrierCount, VkImageMemoryBarrier *pImageMemoryBarriers);
public void CmdWaitEvents(IReadOnlyList<IVkEvent> events, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, IReadOnlyList<VkMemoryBarrier> memoryBarriers, IReadOnlyList<VkBufferMemoryBarrier> bufferMemoryBarriers, IReadOnlyList<VkImageMemoryBarrier> imageMemoryBarriers)
{
var unmanagedSize =
events.SizeOfMarshalDirect() +
memoryBarriers.SizeOfMarshalDirect() +
bufferMemoryBarriers.SizeOfMarshalDirect() +
imageMemoryBarriers.SizeOfMarshalDirect();
var unmanagedArray = new byte[unmanagedSize];
fixed (byte* unmanagedStart = unmanagedArray)
{
var unmanaged = unmanagedStart;
var _commandBuffer = Handle;
var _eventCount = events?.Count ?? 0;
var _pEvents = events.MarshalDirect(ref unmanaged);
var _srcStageMask = srcStageMask;
var _dstStageMask = dstStageMask;
var _memoryBarrierCount = memoryBarriers?.Count ?? 0;
var _pMemoryBarriers = memoryBarriers.MarshalDirect(ref unmanaged);
var _bufferMemoryBarrierCount = bufferMemoryBarriers?.Count ?? 0;
var _pBufferMemoryBarriers = bufferMemoryBarriers.MarshalDirect(ref unmanaged);
var _imageMemoryBarrierCount = imageMemoryBarriers?.Count ?? 0;
var _pImageMemoryBarriers = imageMemoryBarriers.MarshalDirect(ref unmanaged);
Direct.CmdWaitEvents(_commandBuffer, _eventCount, _pEvents, _srcStageMask, _dstStageMask, _memoryBarrierCount, _pMemoryBarriers, _bufferMemoryBarrierCount, _pBufferMemoryBarriers, _imageMemoryBarrierCount, _pImageMemoryBarriers);
}
}
public void CmdPipelineBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, IReadOnlyList<VkMemoryBarrier> memoryBarriers, IReadOnlyList<VkBufferMemoryBarrier> bufferMemoryBarriers, IReadOnlyList<VkImageMemoryBarrier> imageMemoryBarriers)
{
var unmanagedSize =
memoryBarriers.SizeOfMarshalDirect() +
bufferMemoryBarriers.SizeOfMarshalDirect() +
imageMemoryBarriers.SizeOfMarshalDirect();
var unmanagedArray = new byte[unmanagedSize];
fixed (byte* unmanagedStart = unmanagedArray)
{
var unmanaged = unmanagedStart;
var _commandBuffer = Handle;
var _srcStageMask = srcStageMask;
var _dstStageMask = dstStageMask;
var _dependencyFlags = dependencyFlags;
var _memoryBarrierCount = memoryBarriers?.Count ?? 0;
var _pMemoryBarriers = memoryBarriers.MarshalDirect(ref unmanaged);
var _bufferMemoryBarrierCount = bufferMemoryBarriers?.Count ?? 0;
var _pBufferMemoryBarriers = bufferMemoryBarriers.MarshalDirect(ref unmanaged);
var _imageMemoryBarrierCount = imageMemoryBarriers?.Count ?? 0;
var _pImageMemoryBarriers = imageMemoryBarriers.MarshalDirect(ref unmanaged);
Direct.CmdPipelineBarrier(_commandBuffer, _srcStageMask, _dstStageMask, _dependencyFlags, _memoryBarrierCount, _pMemoryBarriers, _bufferMemoryBarrierCount, _pBufferMemoryBarriers, _imageMemoryBarrierCount, _pImageMemoryBarriers);
}
}
public void CmdWriteTimestamp(VkPipelineStageFlags pipelineStage, IVkQueryPool queryPool, int query)
{
var _commandBuffer = Handle;
var _pipelineStage = pipelineStage;
var _queryPool = queryPool?.Handle ?? VkQueryPool.HandleType.Null;
var _query = query;
Direct.CmdWriteTimestamp(_commandBuffer, _pipelineStage, _queryPool, _query);
}
public void CmdWriteTimestamp(
[FromProperty("this")] GenCommandBuffer commandBuffer,
VkPipelineStageFlags pipelineStage,
GenQueryPool queryPool,
int query)
{ }
public void CmdResetEvent(
[FromProperty("this")] GenCommandBuffer commandBuffer,
GenEvent eventObj,
VkPipelineStageFlags stageMask)
{ }
