public void Write <T>(ref T value) where T : struct { if (WriteUsingStagingBuffer) { MemoryRequirements stagingReq = StagingBuffer.GetMemoryRequirements(); IntPtr vertexPtr = StagingMemory.Map(0, stagingReq.Size); Interop.Write(vertexPtr, ref value); StagingMemory.Unmap(); // Copy the data from staging buffers to device local buffers. StagingCommandBuffer.Begin(new CommandBufferBeginInfo(CommandBufferUsages.OneTimeSubmit)); StagingCommandBuffer.CmdCopyBuffer(StagingBuffer, Buffer, new BufferCopy(Size)); StagingCommandBuffer.End(); // Submit. Context.GraphicsQueue.Submit(new SubmitInfo(commandBuffers: new[] { StagingCommandBuffer }), Fence); Fence.Wait(); Fence.Reset(); StagingCommandBuffer.Reset(); return; } IntPtr ptr = Memory.Map(0, Interop.SizeOf <T>()); Interop.Write(ptr, ref value); Memory.Unmap(); }
public void CmdSetDepthParameters() { CommandBuffer.Begin(); CommandBuffer.CmdSetDepthBias(1.0f, 1.0f, 1.0f); CommandBuffer.CmdSetDepthBounds(0.0f, 1.0f); CommandBuffer.End(); }
protected override void OnRecordCommandBuffer(VKImage image, CommandBuffer buffer) { // Begin recording buffer.Begin(new CommandBufferBeginInfo()); // Write commands buffer.CmdPipelineBarrier( srcStageMask: InitialStage, dstStageMask: PipelineStages.ColorAttachmentOutput, imageMemoryBarriers: new ImageMemoryBarrier[] { new ImageMemoryBarrier( image: image.Image, subresourceRange: image.SubresourceRange, srcAccessMask: InitialAccess, dstAccessMask: Accesses.ColorAttachmentWrite, oldLayout: InitialLayout, newLayout: ImageLayout.ColorAttachmentOptimal ) } ); buffer.CmdBeginRenderPass(new RenderPassBeginInfo( Framebuffers[image], RenderPass.RenderPass, new Rect2D(0, 0, image.Extent.Width, image.Extent.Height) )); buffer.CmdBindPipeline(PipelineBindPoint.Graphics, Pipeline); buffer.CmdBindDescriptorSet(PipelineBindPoint.Graphics, PipelineLayout, TextureDescriptorSet); buffer.CmdDraw(3); buffer.CmdEndRenderPass(); // Finish recording buffer.End(); }
public override void Draw(ApplicationTime time) { Device.WaitIdle(); cmd_compute.Begin(); cmd_compute.SetComputePipeline(PipelineState_1); cmd_compute.BindDescriptorSets(DescriptorSet_1); cmd_compute.Dispatch2D(Window.FramebufferSize.Width, Window.FramebufferSize.Height, 8, 8); cmd_compute.Close(); Device.Submit(cmd_compute); Device.ComputeQueueWaitIdle(); CommandBuffer cmd = Context.CommandBuffer; cmd.Begin(); cmd.BeginFramebuffer(Framebuffer); cmd.SetScissor(Window.FramebufferSize.Width, Window.FramebufferSize.Height, 0, 0); cmd.SetViewport(Window.FramebufferSize.Width, Window.FramebufferSize.Height, 0, 0); cmd.BindDescriptorSets(DescriptorSet_0); cmd.SetGraphicPipeline(PipelineState_0); cmd.Draw(3, 1, 0, 0); cmd.Close(); Device.Submit(cmd); SwapChain.Present(); }
public void CmdSetViewports() { CommandBuffer.Begin(); CommandBuffer.CmdSetViewport(new Viewport(0, 0, 32, 32)); CommandBuffer.CmdSetViewports(0, 1, new[] { new Viewport(0, 0, 32, 32) }); CommandBuffer.End(); }
protected override void OnRecordCommandBuffer(VKImage image, CommandBuffer buffer) { // Begin recording buffer.Begin(new CommandBufferBeginInfo()); // Write commands buffer.CmdPipelineBarrier( srcStageMask: InitialStage, dstStageMask: PipelineStages.Transfer, imageMemoryBarriers: new ImageMemoryBarrier[] { new ImageMemoryBarrier( image: image.Image, subresourceRange: image.SubresourceRange, srcAccessMask: InitialAccess, dstAccessMask: Accesses.TransferWrite, oldLayout: InitialLayout, newLayout: ImageLayout.TransferDstOptimal ) } ); buffer.CmdClearColorImage( image.Image, ImageLayout.TransferDstOptimal, ClearColor, image.SubresourceRange ); // Finish recording buffer.End(); }
public void CmdSetScissors() { CommandBuffer.Begin(); CommandBuffer.CmdSetScissor(new Rect2D(Offset2D.Zero, new Extent2D(32, 32))); CommandBuffer.CmdSetScissors(0, 1, new[] { new Rect2D(Offset2D.Zero, new Extent2D(32, 32)) }); CommandBuffer.End(); }
internal void ExecuteBlocking(Action <CommandBuffer> record) { if (record == null) { throw new NullReferenceException(nameof(record)); } ThrowIfDisposed(); //Reset and record the copy instruction into the commandbuffer transientBuffer.Reset(flags: CommandBufferResetFlags.None); //Begin the buffer transientBuffer.Begin(new CommandBufferBeginInfo( flags: CommandBufferUsages.OneTimeSubmit)); record(transientBuffer); //End the buffer transientBuffer.End(); //Submit the copying to the queue queue.Submit( waitSemaphore: null, waitDstStageMask: 0, commandBuffer: transientBuffer, signalSemaphore: null, fence: fence); //Wait for it to execute fence.Wait(); fence.Reset(); }
private void RecordComputeCommandBuffer() { // Record particle movements. var graphicsToComputeBarrier = new BufferMemoryBarrier(_storageBuffer, Accesses.VertexAttributeRead, Accesses.ShaderWrite, Context.GraphicsQueue.FamilyIndex, Context.ComputeQueue.FamilyIndex); var computeToGraphicsBarrier = new BufferMemoryBarrier(_storageBuffer, Accesses.ShaderWrite, Accesses.VertexAttributeRead, Context.ComputeQueue.FamilyIndex, Context.GraphicsQueue.FamilyIndex); _computeCmdBuffer.Begin(); // Add memory barrier to ensure that the (graphics) vertex shader has fetched attributes // before compute starts to write to the buffer. _computeCmdBuffer.CmdPipelineBarrier(PipelineStages.VertexInput, PipelineStages.ComputeShader, bufferMemoryBarriers: new[] { graphicsToComputeBarrier }); _computeCmdBuffer.CmdBindPipeline(PipelineBindPoint.Compute, _computePipeline); _computeCmdBuffer.CmdBindDescriptorSet(PipelineBindPoint.Compute, _computePipelineLayout, _computeDescriptorSet); _computeCmdBuffer.CmdDispatch(_storageBuffer.Count / 256, 1, 1); // Add memory barrier to ensure that compute shader has finished writing to the buffer. // Without this the (rendering) vertex shader may display incomplete results (partial // data from last frame). _computeCmdBuffer.CmdPipelineBarrier(PipelineStages.ComputeShader, PipelineStages.VertexInput, bufferMemoryBarriers: new[] { computeToGraphicsBarrier }); _computeCmdBuffer.End(); }
public override void Draw(ApplicationTime time) { Device.WaitIdle(); CommandBuffer cmd = Context.CommandBuffer; cmd.Begin(); cmd.BeginFramebuffer(Framebuffer); cmd.SetScissor(Window.FramebufferSize.Width, Window.FramebufferSize.Height, 0, 0); cmd.SetViewport(Window.FramebufferSize.Width, Window.FramebufferSize.Height, 0, 0); cmd.BindDescriptorSets(DescriptorSet_0); cmd.SetGraphicPipeline(PipelineState_0); GLTFModel.Draw(cmd, PipelineState_0); cmd.BindDescriptorSets(DescriptorSet_1); cmd.SetGraphicPipeline(PipelineState_1); GLTFModel.Draw(cmd, PipelineState_1); cmd.BindDescriptorSets(DescriptorSet_2); cmd.SetGraphicPipeline(PipelineState_2); GLTFModel.Draw(cmd, PipelineState_2); cmd.Close(); Device.Submit(cmd); SwapChain.Present(); }
public override void Draw(ApplicationTime time) { Device.WaitIdle(); CommandBuffer commandBuffer = Context.CommandBuffer; commandBuffer.Begin(); commandBuffer.BeginFramebuffer(Framebuffer); commandBuffer.SetScissor(Window.FramebufferSize.Width, Window.FramebufferSize.Height, 0, 0); commandBuffer.SetViewport(Window.FramebufferSize.Width, Window.FramebufferSize.Height, 0, 0); commandBuffer.SetGraphicPipeline(PipelineState); commandBuffer.BindDescriptorSets(DescriptorSet); commandBuffer.SetVertexBuffers(new[] { GLTFModel.VertexBuffer }); commandBuffer.SetIndexBuffer(GLTFModel.IndexBuffer, 0, GLTFModel.IndexType); foreach (Scene sc in GLTFModel.Scenes) { foreach (Node node in sc.Root.Children) { RenderNode(commandBuffer, node, sc.Root.LocalMatrix); } } commandBuffer.Close(); Device.Submit(commandBuffer); SwapChain.Present(); }
public void CmdDraw() { var renderPassCreateInfo = new RenderPassCreateInfo(new[] { new SubpassDescription( new[] { new AttachmentReference(0, ImageLayout.ColorAttachmentOptimal) }) }, new[] { new AttachmentDescription { Format = Format.B8G8R8A8UNorm, Samples = SampleCounts.Count1 } }); var imageCreateInfo = new ImageCreateInfo { Usage = ImageUsages.ColorAttachment, Format = Format.B8G8R8A8UNorm, Extent = new Extent3D(2, 2, 1), ImageType = ImageType.Image2D, MipLevels = 1, ArrayLayers = 1, Samples = SampleCounts.Count1 }; var imageViewCreateInfo = new ImageViewCreateInfo( Format.B8G8R8A8UNorm, new ImageSubresourceRange(ImageAspects.Color, 0, 1, 0, 1)); using (ShaderModule vertexShader = Device.CreateShaderModule(new ShaderModuleCreateInfo(ReadAllBytes("Shader.vert.spv")))) using (ShaderModule fragmentShader = Device.CreateShaderModule(new ShaderModuleCreateInfo(ReadAllBytes("Shader.frag.spv")))) using (PipelineLayout pipelineLayout = Device.CreatePipelineLayout()) using (RenderPass renderPass = Device.CreateRenderPass(renderPassCreateInfo)) using (Image image = Device.CreateImage(imageCreateInfo)) { MemoryRequirements imageMemReq = image.GetMemoryRequirements(); int memTypeIndex = PhysicalDeviceMemoryProperties.MemoryTypes.IndexOf(imageMemReq.MemoryTypeBits, MemoryProperties.DeviceLocal); using (DeviceMemory imageMemory = Device.AllocateMemory(new MemoryAllocateInfo(imageMemReq.Size, memTypeIndex))) { image.BindMemory(imageMemory); using (ImageView imageView = image.CreateView(imageViewCreateInfo)) using (Framebuffer framebuffer = renderPass.CreateFramebuffer(new FramebufferCreateInfo(new[] { imageView }, 2, 2))) using (Pipeline pipeline = Device.CreateGraphicsPipeline(new GraphicsPipelineCreateInfo( pipelineLayout, renderPass, 0, new[] { new PipelineShaderStageCreateInfo(ShaderStages.Vertex, vertexShader, "main"), new PipelineShaderStageCreateInfo(ShaderStages.Fragment, fragmentShader, "main") }, new PipelineInputAssemblyStateCreateInfo(), new PipelineVertexInputStateCreateInfo(), new PipelineRasterizationStateCreateInfo { RasterizerDiscardEnable = true, LineWidth = 1.0f }))) { CommandBuffer.Begin(); CommandBuffer.CmdBeginRenderPass(new RenderPassBeginInfo(framebuffer, new Rect2D(0, 0, 2, 2))); CommandBuffer.CmdBindPipeline(PipelineBindPoint.Graphics, pipeline); CommandBuffer.CmdDraw(3); CommandBuffer.CmdEndRenderPass(); CommandBuffer.End(); } } } }
public void CmdSetStencilParameters() { CommandBuffer.Begin(); CommandBuffer.CmdSetStencilCompareMask(StencilFaces.Front, ~0); CommandBuffer.CmdSetStencilReference(StencilFaces.Front, 1); CommandBuffer.CmdSetStencilWriteMask(StencilFaces.Front, ~0); CommandBuffer.End(); }
public void CmdWriteTimestamp() { using (QueryPool queryPool = Device.CreateQueryPool(new QueryPoolCreateInfo(QueryType.Timestamp, 1))) { CommandBuffer.Begin(); CommandBuffer.CmdWriteTimestamp(PipelineStages.AllCommands, queryPool, 0); CommandBuffer.End(); } }
public void CmdResetQueryPool() { using (QueryPool queryPool = Device.CreateQueryPool(new QueryPoolCreateInfo(QueryType.Timestamp, 1))) { CommandBuffer.Begin(); CommandBuffer.CmdResetQueryPool(queryPool, 0, 1); CommandBuffer.End(); } }
public void CmdWaitEvents() { using (Event evt = Device.CreateEvent()) { CommandBuffer.Begin(); CommandBuffer.CmdWaitEvent(evt, PipelineStages.AllCommands, PipelineStages.AllCommands); CommandBuffer.CmdWaitEvents(new[] { evt }, PipelineStages.AllCommands, PipelineStages.AllCommands); CommandBuffer.End(); } }
public void CmdSetAndResetEvent() { using (Event evt = Device.CreateEvent()) { CommandBuffer.Begin(); CommandBuffer.CmdSetEvent(evt, PipelineStages.AllCommands); CommandBuffer.CmdResetEvent(evt, PipelineStages.AllCommands); CommandBuffer.End(); } }
public void CmdBeginAndEndQuery() { using (QueryPool queryPool = Device.CreateQueryPool(new QueryPoolCreateInfo(QueryType.Occlusion, 1))) { CommandBuffer.Begin(); CommandBuffer.CmdBeginQuery(queryPool, 0); CommandBuffer.CmdEndQuery(queryPool, 0); CommandBuffer.End(); } }
private void RecordDispatchCommand() { int computeWorkgroupXCount = (int)Math.Ceiling(Inputs[0].HostResource.Length / 256.0); _commandBuffer.Begin(new CommandBufferBeginInfo(CommandBufferUsages.OneTimeSubmit)); _commandBuffer.CmdBindPipeline(PipelineBindPoint.Compute, _pipeline); _commandBuffer.CmdBindDescriptorSet(PipelineBindPoint.Compute, _pipelineLayout, _descriptorSet); _commandBuffer.CmdDispatch(computeWorkgroupXCount, 1, 1); _commandBuffer.End(); }
public void CmdBeginEndRenderPass() { using (RenderPass renderPass = Device.CreateRenderPass(new RenderPassCreateInfo(new[] { new SubpassDescription(null) }))) using (Framebuffer framebuffer = renderPass.CreateFramebuffer(new FramebufferCreateInfo(null, 32, 32))) { CommandBuffer.Begin(); CommandBuffer.CmdBeginRenderPass(new RenderPassBeginInfo(framebuffer, default(Rect2D))); CommandBuffer.CmdEndRenderPass(); CommandBuffer.End(); } }
public void Run() { while (!window.IsDisposed) { uint imageIndex = device.AcquireNextImageKHR(swapChain, uint.MaxValue, swapChainSemphore); Framebuffer frameBuffer = frameBuffers[imageIndex]; mainCmd.Begin(new CommandBufferBeginInfo { }); mainCmd.CmdBeginRenderPass(new RenderPassBeginInfo { RenderPass = renderPass, Framebuffer = frameBuffer, RenderArea = new Rect2D { Offset = new Offset2D { X = 0, Y = 0 }, Extent = new Extent2D { Width = (uint)surfaceSize.Width, Height = (uint)surfaceSize.Height } }, ClearValues = new ClearValue[] { new ClearValue { Color = new ClearColorValue { Float32 = new [] { 0.0f, 0.2f, 0.5f, 0.0f }, } } } }, SubpassContents.Inline); mainCmd.CmdEndRenderPass(); mainCmd.End(); mainQueue.Submit(new SubmitInfo { CommandBuffers = new CommandBuffer[] { mainCmd }, }); mainQueue.PresentKHR(new PresentInfoKhr { Swapchains = new SwapchainKhr[] { swapChain }, ImageIndices = new uint[] { imageIndex }, WaitSemaphores = new Semaphore[] { swapChainSemphore }, }); mainQueue.WaitIdle(); System.Threading.Thread.Sleep(10); Application.DoEvents(); } device.WaitIdle(); }
public override void Draw(ApplicationTime time) { Device.WaitIdle(); CommandBuffer.Begin(); CommandBuffer.BeginFramebuffer(Framebuffer, r, g, b, 1); CommandBuffer.Close(); Device.Submit(CommandBuffer); SwapChain.Present(); }
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)); }
void SetImageLayout(Image image, ImageAspectFlags aspectMask, ImageLayout oldImageLayout, ImageLayout newImageLayout, AccessFlags srcAccessMask) { if (cmdSetup == null) { cmdSetup = CreateCommandBuffer(QueueFlags.Graphics); cmdSetup.Begin(new CommandBufferBeginInfo()); } ImageMemoryBarrier imageMemoryBarrier = new ImageMemoryBarrier { SrcAccessMask = (uint)srcAccessMask, DstAccessMask = 0, OldLayout = oldImageLayout, NewLayout = newImageLayout, Image = image, SubresourceRange = new ImageSubresourceRange { AspectMask = (uint)aspectMask, BaseMipLevel = 0, LevelCount = 1, BaseArrayLayer = 0, LayerCount = 1, }, }; if (newImageLayout == ImageLayout.TransferDstOptimal) { imageMemoryBarrier.DstAccessMask = (uint)AccessFlags.TransferRead; } else if (newImageLayout == ImageLayout.ColorAttachmentOptimal) { imageMemoryBarrier.DstAccessMask = (uint)AccessFlags.ColorAttachmentWrite; } else if (newImageLayout == ImageLayout.DepthStencilAttachmentOptimal) { imageMemoryBarrier.DstAccessMask = (uint)AccessFlags.DepthStencilAttachmentWrite; } else if (newImageLayout == ImageLayout.ShaderReadOnlyOptimal) { imageMemoryBarrier.DstAccessMask = (uint)(AccessFlags.ShaderRead | AccessFlags.InputAttachmentRead); } // TODO Vulkan : we cant set null as this null->m will be called //cmdSetup.CmdPipelineBarrier(PipelineStageFlags.TopOfPipe, PipelineStageFlags.TopOfPipe, 0, 0, MemoryBarrier.Null, 0, BufferMemoryBarrier.Null, 1, imageMemoryBarrier); cmdSetup.CmdPipelineBarrier(PipelineStageFlags.TopOfPipe, PipelineStageFlags.TopOfPipe, 0, null, null, new ImageMemoryBarrier[] { imageMemoryBarrier }); }
public override void Draw(ResourceSet myResult, VertexBuffer <float> myVertexBuffer, IndexBuffer <UInt32> myIndexBuffer, String PipelineID) { CommandBuffer myBuffer = base.GetNext();//Synchronized for threading myBuffer.Begin(SecondaryBufferBeginInfo); myBuffer.CmdBindDescriptorSets(PipelineBindPoint.Graphics, myActivePipelines[PipelineID].Item1, 0, myResult.myDSet, null); myBuffer.CmdBindPipeline(PipelineBindPoint.Graphics, myActivePipelines[PipelineID].Item2); myBuffer.CmdBindVertexBuffer(0, myVertexBuffer, 0); myBuffer.CmdBindIndexBuffer(myIndexBuffer, 0, IndexType.Uint32); //TODO: Fix this draw indexed and what about instancing myBuffer.CmdDrawIndexed(myIndexBuffer.Count, 1, 0, 0, 0); //TODO: Behind the scenes sort by pipeline ID myBuffer.End(); if (!myDictionary.ContainsKey(PipelineID)) { myDictionary[PipelineID] = new List <CommandBuffer>(); } myDictionary[PipelineID].Add(myBuffer); }
public void Begin() { CommandBuffer.Begin(new CommandBufferBeginInfo(CommandBufferUsages.SimultaneousUse)); if (Context.PresentQueue != Context.GraphicsQueue) { var barrierFromPresentToDraw = new ImageMemoryBarrier( Image.Image, DefaultSubresourceRangeColor, Accesses.MemoryRead, Accesses.ColorAttachmentWrite, ImageLayout.Undefined, ImageLayout.PresentSrcKhr, Context.PresentQueue.FamilyIndex, Context.GraphicsQueue.FamilyIndex); CommandBuffer.CmdPipelineBarrier( PipelineStages.ColorAttachmentOutput, PipelineStages.ColorAttachmentOutput, imageMemoryBarriers: new[] { barrierFromPresentToDraw }); } }
public void CmdCopyQueryPoolResults() { const long bufferSize = 256L; using (QueryPool queryPool = Device.CreateQueryPool(new QueryPoolCreateInfo(QueryType.Timestamp, 1))) using (Buffer buffer = Device.CreateBuffer(new BufferCreateInfo(bufferSize, BufferUsages.TransferDst))) using (DeviceMemory memory = Device.AllocateMemory(new MemoryAllocateInfo(bufferSize, 0))) { // Required to keep the validation layer happy. // Ideally we should allocate memory based on these requirements. buffer.GetMemoryRequirements(); buffer.BindMemory(memory); CommandBuffer.Begin(); CommandBuffer.CmdCopyQueryPoolResults(queryPool, 0, 1, buffer, 0, bufferSize); CommandBuffer.End(); } }
void CreateCommandBuffer(CommandBuffer cmdBuffer, VertexData vertexData, RenderPass renderPass, PipelineLayout pipelineLayout, Pipeline pipeline, DescriptorSet descriptorSet, ImageData swapchainImageData, Framebuffer framebuffer) { var beginInfo = new CommandBufferBeginInfo(); cmdBuffer.Begin(beginInfo); beginInfo.Dispose(); PipelineBarrierSetLayout(cmdBuffer, swapchainImageData.Image, ImageLayout.PresentSrcKHR, ImageLayout.ColorAttachmentOptimal, AccessFlags.MemoryRead, AccessFlags.ColorAttachmentWrite); var clearRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1); cmdBuffer.ClearColorImage(swapchainImageData.Image, ImageLayout.TransferDstOptimal, new ClearColorValue(), new[] { clearRange }); RenderTexturedQuad(cmdBuffer, vertexData, swapchainImageData, pipelineLayout, descriptorSet, renderPass, pipeline, framebuffer, swapchainImageData.Width, swapchainImageData.Height); PipelineBarrierSetLayout(cmdBuffer, swapchainImageData.Image, ImageLayout.ColorAttachmentOptimal, ImageLayout.PresentSrcKHR, AccessFlags.ColorAttachmentWrite, AccessFlags.MemoryRead); cmdBuffer.End(); }
public void BeginBuffer(CommandBuffer cb, int frameBufIndex, ClearValue cv) { CommandBufferBeginInfo cbbi = new CommandBufferBeginInfo(); cbbi.Flags = CommandBufferUsages.SimultaneousUse; cb.Begin(cbbi); RenderPassBeginInfo rpbi = new RenderPassBeginInfo( mChainBuffers[frameBufIndex], new Rect2D(Offset2D.Zero, mDevices.GetChainExtent()), cv); //rpbi.ClearValues =cv; cb.CmdBeginRenderPass(rpbi); cb.CmdBindPipeline(PipelineBindPoint.Graphics, mPipe); }