private unsafe void CreateBackBuffers()
{
backbuffer.OnDestroyed();
// Create the texture object
var backBufferDescription = new TextureDescription
{
ArraySize = 1,
Dimension = TextureDimension.Texture2D,
Height = Description.BackBufferHeight,
Width = Description.BackBufferWidth,
Depth = 1,
Flags = TextureFlags.RenderTarget,
Format = Description.BackBufferFormat,
MipLevels = 1,
MultisampleCount = MultisampleCount.None,
Usage = GraphicsResourceUsage.Default
};
backbuffer.InitializeWithoutResources(backBufferDescription);
var createInfo = new ImageViewCreateInfo
{
StructureType = StructureType.ImageViewCreateInfo,
SubresourceRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1),
Format = backbuffer.NativeFormat,
ViewType = ImageViewType.Image2D
};
// We initialize swapchain images to PresentSource, since we swap them out while in this layout.
backbuffer.NativeAccessMask = AccessFlags.MemoryRead;
backbuffer.NativeLayout = ImageLayout.PresentSource;
var imageMemoryBarrier = new ImageMemoryBarrier
{
StructureType = StructureType.ImageMemoryBarrier,
SubresourceRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1),
OldLayout = ImageLayout.Undefined,
NewLayout = ImageLayout.PresentSource,
SourceAccessMask = AccessFlags.None,
DestinationAccessMask = AccessFlags.MemoryRead
};
var commandBuffer = GraphicsDevice.NativeCopyCommandBuffer;
var beginInfo = new CommandBufferBeginInfo {
StructureType = StructureType.CommandBufferBeginInfo
};
commandBuffer.Begin(ref beginInfo);
var buffers = GraphicsDevice.NativeDevice.GetSwapchainImages(swapChain);
swapchainImages = new SwapChainImageInfo[buffers.Length];
for (int i = 0; i < buffers.Length; i++)
{
// Create image views
swapchainImages[i].NativeImage = createInfo.Image = buffers[i];
swapchainImages[i].NativeColorAttachmentView = GraphicsDevice.NativeDevice.CreateImageView(ref createInfo);
// Transition to default layout
imageMemoryBarrier.Image = buffers[i];
commandBuffer.PipelineBarrier(PipelineStageFlags.AllCommands, PipelineStageFlags.AllCommands, DependencyFlags.None, 0, null, 0, null, 1, &imageMemoryBarrier);
}
// Close and submit
commandBuffer.End();
var submitInfo = new SubmitInfo
{
StructureType = StructureType.SubmitInfo,
CommandBufferCount = 1,
CommandBuffers = new IntPtr(&commandBuffer),
};
GraphicsDevice.NativeCommandQueue.Submit(1, &submitInfo, Fence.Null);
GraphicsDevice.NativeCommandQueue.WaitIdle();
commandBuffer.Reset(CommandBufferResetFlags.None);
// need to make a fence, but can immediately reset it, as it acts as a dummy
var fenceCreateInfo = new FenceCreateInfo {
StructureType = StructureType.FenceCreateInfo
};
presentFence = GraphicsDevice.NativeDevice.CreateFence(ref fenceCreateInfo);
currentBufferIndex = GraphicsDevice.NativeDevice.AcquireNextImage(swapChain, ulong.MaxValue, SharpVulkan.Semaphore.Null, presentFence);
fixed(Fence *fences = &presentFence)
{
GraphicsDevice.NativeDevice.ResetFences(1, fences);
}
// Apply the first swap chain image to the texture
backbuffer.SetNativeHandles(swapchainImages[currentBufferIndex].NativeImage, swapchainImages[currentBufferIndex].NativeColorAttachmentView);
}
/// <summary>
/// Explicitly recreate buffer with given data. Usually called after a <see cref="GraphicsDevice"/> reset.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dataPointer"></param>
public unsafe void Recreate(IntPtr dataPointer)
{
// capture vertex information for things less than ~512 verts for possible later easy batching
if (dataPointer != IntPtr.Zero &&
(ViewFlags == BufferFlags.VertexBuffer && bufferDescription.SizeInBytes <= CaptureVertexBuffersOfSize ||
ViewFlags == BufferFlags.IndexBuffer && bufferDescription.SizeInBytes <= CaptureIndexBuffersOfSize))
{
VertIndexData = new byte[Description.SizeInBytes];
fixed(byte *vid = &VertIndexData[0])
{
Utilities.CopyMemory((IntPtr)vid, dataPointer, VertIndexData.Length);
}
}
else
{
VertIndexData = null;
}
var createInfo = new BufferCreateInfo
{
StructureType = StructureType.BufferCreateInfo,
Size = (ulong)bufferDescription.SizeInBytes,
Flags = BufferCreateFlags.None,
};
createInfo.Usage |= BufferUsageFlags.TransferSource;
// We always fill using transfer
//if (bufferDescription.Usage != GraphicsResourceUsage.Immutable)
createInfo.Usage |= BufferUsageFlags.TransferDestination;
if (Usage == GraphicsResourceUsage.Staging)
{
NativeAccessMask = AccessFlags.HostRead | AccessFlags.HostWrite;
NativePipelineStageMask |= PipelineStageFlags.Host;
}
else
{
if ((ViewFlags & BufferFlags.VertexBuffer) != 0)
{
createInfo.Usage |= BufferUsageFlags.VertexBuffer;
NativeAccessMask |= AccessFlags.VertexAttributeRead;
NativePipelineStageMask |= PipelineStageFlags.VertexInput;
}
if ((ViewFlags & BufferFlags.IndexBuffer) != 0)
{
createInfo.Usage |= BufferUsageFlags.IndexBuffer;
NativeAccessMask |= AccessFlags.IndexRead;
NativePipelineStageMask |= PipelineStageFlags.VertexInput;
}
if ((ViewFlags & BufferFlags.ConstantBuffer) != 0)
{
createInfo.Usage |= BufferUsageFlags.UniformBuffer;
NativeAccessMask |= AccessFlags.UniformRead;
NativePipelineStageMask |= PipelineStageFlags.VertexShader | PipelineStageFlags.FragmentShader;
}
if ((ViewFlags & BufferFlags.ShaderResource) != 0)
{
createInfo.Usage |= BufferUsageFlags.UniformTexelBuffer;
NativeAccessMask |= AccessFlags.ShaderRead;
NativePipelineStageMask |= PipelineStageFlags.VertexShader | PipelineStageFlags.FragmentShader;
if ((ViewFlags & BufferFlags.UnorderedAccess) != 0)
{
createInfo.Usage |= BufferUsageFlags.StorageTexelBuffer;
NativeAccessMask |= AccessFlags.ShaderWrite;
}
}
}
// Create buffer
NativeBuffer = GraphicsDevice.NativeDevice.CreateBuffer(ref createInfo);
// Allocate memory
var memoryProperties = MemoryPropertyFlags.DeviceLocal;
if (bufferDescription.Usage == GraphicsResourceUsage.Staging || Usage == GraphicsResourceUsage.Dynamic)
{
memoryProperties = MemoryPropertyFlags.HostVisible | MemoryPropertyFlags.HostCoherent;
}
MemoryRequirements memoryRequirements;
GraphicsDevice.NativeDevice.GetBufferMemoryRequirements(NativeBuffer, out memoryRequirements);
AllocateMemory(memoryProperties, memoryRequirements);
if (NativeMemory != DeviceMemory.Null)
{
GraphicsDevice.NativeDevice.BindBufferMemory(NativeBuffer, NativeMemory, 0);
}
if (SizeInBytes > 0)
{
// Begin copy command buffer
var commandBufferAllocateInfo = new CommandBufferAllocateInfo
{
StructureType = StructureType.CommandBufferAllocateInfo,
CommandPool = GraphicsDevice.NativeCopyCommandPool,
CommandBufferCount = 1,
Level = CommandBufferLevel.Primary
};
CommandBuffer commandBuffer;
lock (GraphicsDevice.QueueLock)
{
GraphicsDevice.NativeDevice.AllocateCommandBuffers(ref commandBufferAllocateInfo, &commandBuffer);
}
var beginInfo = new CommandBufferBeginInfo {
StructureType = StructureType.CommandBufferBeginInfo, Flags = CommandBufferUsageFlags.OneTimeSubmit
};
commandBuffer.Begin(ref beginInfo);
// Copy to upload buffer
if (dataPointer != IntPtr.Zero)
{
if (Usage == GraphicsResourceUsage.Dynamic)
{
var uploadMemory = GraphicsDevice.NativeDevice.MapMemory(NativeMemory, 0, (ulong)SizeInBytes, MemoryMapFlags.None);
Utilities.CopyMemory(uploadMemory, dataPointer, SizeInBytes);
lock (GraphicsDevice.QueueLock)
{
GraphicsDevice.NativeDevice.UnmapMemory(NativeMemory);
}
}
else
{
var sizeInBytes = bufferDescription.SizeInBytes;
SharpVulkan.Buffer uploadResource;
int uploadOffset;
var uploadMemory = GraphicsDevice.AllocateUploadBuffer(sizeInBytes, out uploadResource, out uploadOffset);
Utilities.CopyMemory(uploadMemory, dataPointer, sizeInBytes);
// Barrier
var memoryBarrier = new BufferMemoryBarrier(uploadResource, AccessFlags.HostWrite, AccessFlags.TransferRead, (ulong)uploadOffset, (ulong)sizeInBytes);
commandBuffer.PipelineBarrier(PipelineStageFlags.Host, PipelineStageFlags.Transfer, DependencyFlags.None, 0, null, 1, &memoryBarrier, 0, null);
// Copy
var bufferCopy = new BufferCopy
{
SourceOffset = (uint)uploadOffset,
DestinationOffset = 0,
Size = (uint)sizeInBytes
};
lock (GraphicsDevice.QueueLock)
{
commandBuffer.CopyBuffer(uploadResource, NativeBuffer, 1, &bufferCopy);
}
}
}
else
{
commandBuffer.FillBuffer(NativeBuffer, 0, (uint)bufferDescription.SizeInBytes, 0);
}
// Barrier
var bufferMemoryBarrier = new BufferMemoryBarrier(NativeBuffer, AccessFlags.TransferWrite, NativeAccessMask);
commandBuffer.PipelineBarrier(PipelineStageFlags.Transfer, PipelineStageFlags.AllCommands, DependencyFlags.None, 0, null, 1, &bufferMemoryBarrier, 0, null);
// Close and submit
commandBuffer.End();
var submitInfo = new SubmitInfo
{
StructureType = StructureType.SubmitInfo,
CommandBufferCount = 1,
CommandBuffers = new IntPtr(&commandBuffer),
};
var fenceCreateInfo = new FenceCreateInfo {
StructureType = StructureType.FenceCreateInfo
};
var fence = GraphicsDevice.NativeDevice.CreateFence(ref fenceCreateInfo);
lock (GraphicsDevice.QueueLock) {
GraphicsDevice.NativeCommandQueue.Submit(1, &submitInfo, fence);
GraphicsDevice.NativeDevice.WaitForFences(1, &fence, true, ulong.MaxValue);
}
GraphicsDevice.NativeDevice.FreeCommandBuffers(GraphicsDevice.NativeCopyCommandPool, 1, &commandBuffer);
GraphicsDevice.NativeDevice.DestroyFence(fence);
InitializeViews();
}
}
internal static unsafe extern Result vkCreateFence(Device device, FenceCreateInfo* createInfo, AllocationCallbacks* allocator, Fence* fence);
private unsafe void InitializeImage(DataBox[] dataBoxes)
{
// Begin copy command buffer
var commandBufferAllocateInfo = new CommandBufferAllocateInfo
{
StructureType = StructureType.CommandBufferAllocateInfo,
CommandPool = GraphicsDevice.NativeCopyCommandPool,
CommandBufferCount = 1,
Level = CommandBufferLevel.Primary
};
CommandBuffer commandBuffer;
// do some setup outside of the lock
var beginInfo = new CommandBufferBeginInfo {
StructureType = StructureType.CommandBufferBeginInfo, Flags = CommandBufferUsageFlags.OneTimeSubmit
};
var fenceCreateInfo = new FenceCreateInfo {
StructureType = StructureType.FenceCreateInfo
};
var fence = GraphicsDevice.NativeDevice.CreateFence(ref fenceCreateInfo);
var submitInfo = new SubmitInfo
{
StructureType = StructureType.SubmitInfo,
CommandBufferCount = 1,
};
lock (GraphicsDevice.QueueLock) {
GraphicsDevice.NativeDevice.AllocateCommandBuffers(ref commandBufferAllocateInfo, &commandBuffer);
}
commandBuffer.Begin(ref beginInfo);
if (dataBoxes != null && dataBoxes.Length > 0)
{
// Buffer-to-image copies need to be aligned to the pixel size and 4 (always a power of 2)
var blockSize = Format.IsCompressed() ? NativeFormat.BlockSizeInBytes() : TexturePixelSize;
var alignmentMask = (blockSize < 4 ? 4 : blockSize) - 1;
int totalSize = dataBoxes.Length * alignmentMask;
for (int i = 0; i < dataBoxes.Length; i++)
{
totalSize += dataBoxes[i].SlicePitch;
}
SharpVulkan.Buffer uploadResource;
int uploadOffset;
var uploadMemory = GraphicsDevice.AllocateUploadBuffer(totalSize, out uploadResource, out uploadOffset);
// Upload buffer barrier
var bufferMemoryBarrier = new BufferMemoryBarrier(uploadResource, AccessFlags.None, AccessFlags.TransferRead, (ulong)uploadOffset, (ulong)totalSize);
// Image barrier
NativeLayout = ImageLayout.TransferDestinationOptimal;
var initialBarrier = new ImageMemoryBarrier(NativeImage, ImageLayout.Undefined, NativeLayout, AccessFlags.None, AccessFlags.TransferWrite, new ImageSubresourceRange(NativeImageAspect));
commandBuffer.PipelineBarrier(PipelineStageFlags.Host, PipelineStageFlags.Transfer, DependencyFlags.None, 0, null, 1, &bufferMemoryBarrier, 1, &initialBarrier);
// Copy data boxes to upload buffer
var copies = new BufferImageCopy[dataBoxes.Length];
for (int i = 0; i < copies.Length; i++)
{
var slicePitch = dataBoxes[i].SlicePitch;
int arraySlice = i / MipLevels;
int mipSlice = i % MipLevels;
var mipMapDescription = GetMipMapDescription(mipSlice);
var alignment = ((uploadOffset + alignmentMask) & ~alignmentMask) - uploadOffset;
uploadMemory += alignment;
uploadOffset += alignment;
Utilities.CopyMemory(uploadMemory, dataBoxes[i].DataPointer, slicePitch);
// TODO VULKAN: Check if pitches are valid
copies[i] = new BufferImageCopy
{
BufferOffset = (ulong)uploadOffset,
ImageSubresource = new ImageSubresourceLayers(ImageAspectFlags.Color, (uint)arraySlice, 1, (uint)mipSlice),
BufferRowLength = 0, //(uint)(dataBoxes[i].RowPitch / pixelSize),
BufferImageHeight = 0, //(uint)(dataBoxes[i].SlicePitch / dataBoxes[i].RowPitch),
ImageOffset = new Offset3D(0, 0, 0),
ImageExtent = new Extent3D((uint)mipMapDescription.Width, (uint)mipMapDescription.Height, (uint)mipMapDescription.Depth)
};
uploadMemory += slicePitch;
uploadOffset += slicePitch;
}
// Copy from upload buffer to image
lock (GraphicsDevice.QueueLock)
{
fixed(BufferImageCopy *copiesPointer = copies)
{
commandBuffer.CopyBufferToImage(uploadResource, NativeImage, ImageLayout.TransferDestinationOptimal, (uint)copies.Length, copiesPointer);
}
}
IsInitialized = true;
}
// Transition to default layout
var imageMemoryBarrier = new ImageMemoryBarrier(NativeImage,
dataBoxes == null || dataBoxes.Length == 0 ? ImageLayout.Undefined : ImageLayout.TransferDestinationOptimal, NativeLayout,
dataBoxes == null || dataBoxes.Length == 0 ? AccessFlags.None : AccessFlags.TransferWrite, NativeAccessMask, new ImageSubresourceRange(NativeImageAspect));
submitInfo.CommandBuffers = new IntPtr(&commandBuffer);
// Close and submit
lock (GraphicsDevice.QueueLock) {
commandBuffer.PipelineBarrier(PipelineStageFlags.Transfer, PipelineStageFlags.AllCommands, DependencyFlags.None, 0, null, 0, null, 1, &imageMemoryBarrier);
commandBuffer.End();
GraphicsDevice.NativeCommandQueue.Submit(1, &submitInfo, fence);
GraphicsDevice.NativeDevice.WaitForFences(1, &fence, true, ulong.MaxValue);
}
GraphicsDevice.NativeDevice.FreeCommandBuffers(GraphicsDevice.NativeCopyCommandPool, 1, &commandBuffer);
GraphicsDevice.NativeDevice.DestroyFence(fence);
}
public unsafe Fence CreateFence(ref FenceCreateInfo createInfo, AllocationCallbacks* allocator = null)
{
Fence fence;
fixed (FenceCreateInfo* __createInfo__ = &createInfo)
{
vkCreateFence(this, __createInfo__, allocator, &fence).CheckError();
}
return fence;
}
