//释放资源
public void Dispose()
{
//等待GPU处理完所有的资源
WaitForPreviousFrame();
//释放所有资源
foreach (var target in renderTargets)
{
target.Dispose();
}
commandAllocator.Dispose();
bundleAllocator.Dispose();
commandQueue.Dispose();
rootSignature.Dispose();
pipelineState.Dispose();
vertexBuffer.Dispose();
texture.Dispose();
indexBuffer.Dispose();
renderTargetViewHeap.Dispose();
commandList.Dispose();
bundle.Dispose();
fence.Dispose();
swapChain.Dispose();
device.Dispose();
}
/// <inheritdoc/>
protected internal override void OnDestroyed()
{
NativeQueryHeap.Dispose();
readbackBuffer.Dispose();
readbackFence.Dispose();
base.OnDestroyed();
}
public void Dispose()
{
ThrowIfDisposed();
transientBuffer.Dispose();
commandPool.Dispose();
fence.Dispose();
disposed = true;
}
protected override void DisposeManaged()
{
base.DisposeManaged();
targetColor.Dispose();
targetDepth.Dispose();
Framebuffer.Dispose();
commandList.Dispose();
fence.Dispose();
}
public void Dispose()
{
Fence?.Dispose();
Memory.Dispose();
Buffer.Dispose();
if (WriteUsingStagingBuffer)
{
StagingMemory?.Dispose();
StagingBuffer?.Dispose();
StagingCommandBuffer?.Dispose();
}
}
public static VulkanBuffer Vertex <T>(VulkanContext ctx, T[] vertices) where T : struct
{
long size = vertices.Length * Interop.SizeOf <T>();
// Create a staging buffer that is writable by host.
Buffer stagingBuffer = ctx.Device.CreateBuffer(new BufferCreateInfo(size, BufferUsages.TransferSrc));
MemoryRequirements stagingReq = stagingBuffer.GetMemoryRequirements();
int stagingMemoryTypeIndex = ctx.MemoryProperties.MemoryTypes.IndexOf(
stagingReq.MemoryTypeBits,
MemoryProperties.HostVisible | MemoryProperties.HostCoherent);
DeviceMemory stagingMemory = ctx.Device.AllocateMemory(new MemoryAllocateInfo(stagingReq.Size, stagingMemoryTypeIndex));
IntPtr vertexPtr = stagingMemory.Map(0, stagingReq.Size);
Interop.Write(vertexPtr, vertices);
stagingMemory.Unmap();
stagingBuffer.BindMemory(stagingMemory);
// Create a device local buffer where the vertex data will be copied and which will be used for rendering.
Buffer buffer = ctx.Device.CreateBuffer(new BufferCreateInfo(size, BufferUsages.VertexBuffer | BufferUsages.TransferDst));
MemoryRequirements req = buffer.GetMemoryRequirements();
int memoryTypeIndex = ctx.MemoryProperties.MemoryTypes.IndexOf(
req.MemoryTypeBits,
MemoryProperties.DeviceLocal);
DeviceMemory memory = ctx.Device.AllocateMemory(new MemoryAllocateInfo(req.Size, memoryTypeIndex));
buffer.BindMemory(memory);
// Copy the data from staging buffers to device local buffers.
CommandBuffer cmdBuffer = ctx.GraphicsCommandPool.AllocateBuffers(new CommandBufferAllocateInfo(CommandBufferLevel.Primary, 1))[0];
cmdBuffer.Begin(new CommandBufferBeginInfo(CommandBufferUsages.OneTimeSubmit));
cmdBuffer.CmdCopyBuffer(stagingBuffer, buffer, new BufferCopy(size));
cmdBuffer.End();
// Submit.
Fence fence = ctx.Device.CreateFence();
ctx.GraphicsQueue.Submit(new SubmitInfo(commandBuffers: new[] { cmdBuffer }), fence);
fence.Wait();
// Cleanup.
fence.Dispose();
cmdBuffer.Dispose();
stagingBuffer.Dispose();
stagingMemory.Dispose();
return(new VulkanBuffer(buffer, memory, vertices.Length));
}
internal static VKBuffer Index(Context ctx, int[] indices)
{
long size = indices.Length * sizeof(int);
// Create staging buffer.
VulkanCore.Buffer stagingBuffer = ctx.Device.CreateBuffer(new BufferCreateInfo(size, BufferUsages.TransferSrc));
MemoryRequirements stagingReq = stagingBuffer.GetMemoryRequirements();
int stagingMemoryTypeIndex = ctx.MemoryProperties.MemoryTypes.IndexOf(
stagingReq.MemoryTypeBits,
MemoryProperties.HostVisible | MemoryProperties.HostCoherent);
DeviceMemory stagingMemory = ctx.Device.AllocateMemory(new MemoryAllocateInfo(stagingReq.Size, stagingMemoryTypeIndex));
IntPtr indexPtr = stagingMemory.Map(0, stagingReq.Size);
Interop.Write(indexPtr, indices);
stagingMemory.Unmap();
stagingBuffer.BindMemory(stagingMemory);
// Create a device local buffer.
VulkanCore.Buffer buffer = ctx.Device.CreateBuffer(new BufferCreateInfo(size, BufferUsages.IndexBuffer | BufferUsages.TransferDst));
MemoryRequirements req = buffer.GetMemoryRequirements();
int memoryTypeIndex = ctx.MemoryProperties.MemoryTypes.IndexOf(
req.MemoryTypeBits,
MemoryProperties.DeviceLocal);
DeviceMemory memory = ctx.Device.AllocateMemory(new MemoryAllocateInfo(req.Size, memoryTypeIndex));
buffer.BindMemory(memory);
// Copy the data from staging buffer to device local buffer.
CommandBuffer cmdBuffer = ctx.GraphicsCommandPool.AllocateBuffers(new CommandBufferAllocateInfo(CommandBufferLevel.Primary, 1))[0];
cmdBuffer.Begin(new CommandBufferBeginInfo(CommandBufferUsages.OneTimeSubmit));
cmdBuffer.CmdCopyBuffer(stagingBuffer, buffer, new BufferCopy(size));
cmdBuffer.End();
// Submit.
Fence fence = ctx.Device.CreateFence();
ctx.GraphicsQueue.Submit(new SubmitInfo(commandBuffers: new[] { cmdBuffer }), fence);
fence.Wait();
// Cleanup.
fence.Dispose();
cmdBuffer.Dispose();
stagingBuffer.Dispose();
stagingMemory.Dispose();
return(new VKBuffer(ctx, buffer, memory, null, indices.Length, size));
}
public void Dispose()
{
if (_disposed)
{
return;
}
Output.Dispose();
Inputs.ForEach(input => input.Dispose());
_descriptorPool.Dispose();
_pipeline.Dispose();
_pipelineLayout.Dispose();
_descriptorSetLayout.Dispose();
_commandPool.Dispose();
_fence.Dispose();
_disposed = true;
}
public Boolean Initialize()
{
Fence fence = null;
fence = m_DeviceRef.Device.CreateFence(0, FenceFlags.None);
if (fence == null)
{
return(false);
}
m_Fence = fence;
fence.Dispose();
m_Fence.Signal(Interlocked.Read(ref m_LastCompletedValue));
m_FenceEvent = new AutoResetEvent(false);
return(true);
}
public void Dispose()
{
WaitForPreviousFrame();
foreach (var target in renderTargets)
{
target.Dispose();
}
commandAllocator.Dispose();
commandQueue.Dispose();
rootSignature.Dispose();
renderTargetViewHeap.Dispose();
pipelineState.Dispose();
commandList.Dispose();
vertexBuffer.Dispose();
fence.Dispose();
swapChain.Dispose();
device.Dispose();
}
public void Dispose()
{
// Wait for the GPU to be done with all resources.
WaitForPreviousFrame();
foreach (var target in _renderTargets)
{
target.Dispose();
}
_commandAllocator.Dispose();
_graphicsQueue.Dispose();
_rootSignature.Dispose();
_renderTargetViewHeap.Dispose();
_pipelineState.Dispose();
_commandList.Dispose();
_fence.Dispose();
_swapChain.Dispose();
_device.Dispose();
}
public void Dispose()
{
WaitForPrevFrame();
swapChain.SetFullscreenState(false, null);
foreach (var target in renderTargets)
{
target.Dispose();
}
CommandAllocator.Dispose();
CommandQueue.Dispose();
rtvHeap.Dispose();
fence.Dispose();
swapChain.Dispose();
device.Dispose();
window?.Dispose();
}
protected virtual void Dispose(bool disposing)
{
// Implements the basic dispose pattern.
// Ref: https://msdn.microsoft.com/en-us/library/b1yfkh5e(v=vs.110).aspx
if (disposing)
{
FlushCommandQueue();
RtvHeap?.Dispose();
DsvHeap?.Dispose();
SwapChain?.Dispose();
foreach (Resource buffer in _swapChainBuffers)
{
buffer?.Dispose();
}
DepthStencilBuffer?.Dispose();
CommandList?.Dispose();
DirectCmdListAlloc?.Dispose();
CommandQueue?.Dispose();
Fence?.Dispose();
Device?.Dispose();
}
}
void RunCommandBuffer()
{
/*
* Now we shall finally submit the recorded command buffer to a queue.
*/
SubmitInfo submitInfo = new SubmitInfo()
{
CommandBuffers = commandBuffers.ToHandleArray() // the command buffer to submit.
};
/*
* We create a fence.
*/
FenceCreateInfo fenceCreateInfo = new FenceCreateInfo()
{
Flags = 0
};
Fence fence = device.CreateFence(fenceCreateInfo);
/*
* We submit the command buffer on the queue, at the same time giving a fence.
*/
queue.Submit(submitInfo, fence);
/*
* The command will not have finished executing until the fence is signalled.
* So we wait here.
* We will directly after this read our buffer from the GPU,
* and we will not be sure that the command has finished executing unless we wait for the fence.
* Hence, we use a fence here.
*/
fence.Wait();
fence.Dispose();
}
public void Dispose()
{
NativeCommandQueue.Dispose();
Fence.Dispose();
}
internal static VulkanImage Texture2D(VulkanContext ctx, TextureData tex2D)
{
Buffer stagingBuffer = ctx.Device.CreateBuffer(
new BufferCreateInfo(tex2D.Mipmaps[0].Size, BufferUsages.TransferSrc));
MemoryRequirements stagingMemReq = stagingBuffer.GetMemoryRequirements();
int heapIndex = ctx.MemoryProperties.MemoryTypes.IndexOf(
stagingMemReq.MemoryTypeBits, MemoryProperties.HostVisible);
DeviceMemory stagingMemory = ctx.Device.AllocateMemory(
new MemoryAllocateInfo(stagingMemReq.Size, heapIndex));
stagingBuffer.BindMemory(stagingMemory);
IntPtr ptr = stagingMemory.Map(0, stagingMemReq.Size);
Interop.Write(ptr, tex2D.Mipmaps[0].Data);
stagingMemory.Unmap();
// Setup buffer copy regions for each mip level.
var bufferCopyRegions = new BufferImageCopy[tex2D.Mipmaps.Length];
int offset = 0;
for (int i = 0; i < bufferCopyRegions.Length; i++)
{
bufferCopyRegions = new[]
{
new BufferImageCopy
{
ImageSubresource = new ImageSubresourceLayers(ImageAspects.Color, i, 0, 1),
ImageExtent = tex2D.Mipmaps[0].Extent,
BufferOffset = offset
}
};
offset += tex2D.Mipmaps[i].Size;
}
// Create optimal tiled target image.
Image image = ctx.Device.CreateImage(new ImageCreateInfo
{
ImageType = ImageType.Image2D,
Format = tex2D.Format,
MipLevels = tex2D.Mipmaps.Length,
ArrayLayers = 1,
Samples = SampleCounts.Count1,
Tiling = ImageTiling.Optimal,
SharingMode = SharingMode.Exclusive,
InitialLayout = ImageLayout.Undefined,
Extent = tex2D.Mipmaps[0].Extent,
Usage = ImageUsages.Sampled | ImageUsages.TransferDst
});
MemoryRequirements imageMemReq = image.GetMemoryRequirements();
int imageHeapIndex = ctx.MemoryProperties.MemoryTypes.IndexOf(
imageMemReq.MemoryTypeBits, MemoryProperties.DeviceLocal);
DeviceMemory memory = ctx.Device.AllocateMemory(new MemoryAllocateInfo(imageMemReq.Size, imageHeapIndex));
image.BindMemory(memory);
var subresourceRange = new ImageSubresourceRange(ImageAspects.Color, 0, tex2D.Mipmaps.Length, 0, 1);
// Copy the data from staging buffers to device local buffers.
CommandBuffer cmdBuffer = ctx.GraphicsCommandPool.AllocateBuffers(new CommandBufferAllocateInfo(CommandBufferLevel.Primary, 1))[0];
cmdBuffer.Begin(new CommandBufferBeginInfo(CommandBufferUsages.OneTimeSubmit));
cmdBuffer.CmdPipelineBarrier(PipelineStages.TopOfPipe, PipelineStages.TopOfPipe,
imageMemoryBarriers: new[]
{
new ImageMemoryBarrier(
image, subresourceRange,
0, Accesses.TransferWrite,
ImageLayout.Undefined, ImageLayout.TransferDstOptimal)
});
cmdBuffer.CmdCopyBufferToImage(stagingBuffer, image, ImageLayout.TransferDstOptimal, bufferCopyRegions);
cmdBuffer.CmdPipelineBarrier(PipelineStages.TopOfPipe, PipelineStages.TopOfPipe,
imageMemoryBarriers: new[]
{
new ImageMemoryBarrier(
image, subresourceRange,
Accesses.TransferWrite, Accesses.ShaderRead,
ImageLayout.TransferDstOptimal, ImageLayout.ShaderReadOnlyOptimal)
});
cmdBuffer.End();
// Submit.
Fence fence = ctx.Device.CreateFence();
ctx.GraphicsQueue.Submit(new SubmitInfo(commandBuffers: new[] { cmdBuffer }), fence);
fence.Wait();
// Cleanup staging resources.
fence.Dispose();
stagingMemory.Dispose();
stagingBuffer.Dispose();
// Create image view.
ImageView view = image.CreateView(new ImageViewCreateInfo(tex2D.Format, subresourceRange));
return(new VulkanImage(image, memory, view, tex2D.Format));
}