Exemple #1
0
        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();
        }
Exemple #2
0
 public void CmdSetDepthParameters()
 {
     CommandBuffer.Begin();
     CommandBuffer.CmdSetDepthBias(1.0f, 1.0f, 1.0f);
     CommandBuffer.CmdSetDepthBounds(0.0f, 1.0f);
     CommandBuffer.End();
 }
Exemple #3
0
 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();
 }
Exemple #4
0
        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();
        }
Exemple #5
0
 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();
 }
Exemple #6
0
 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();
 }
Exemple #7
0
 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();
 }
Exemple #8
0
        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();
        }
Exemple #10
0
        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();
        }
Exemple #11
0
        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();
        }
Exemple #12
0
        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();
                                            }
                                }
                            }
        }
Exemple #13
0
 public void CmdSetStencilParameters()
 {
     CommandBuffer.Begin();
     CommandBuffer.CmdSetStencilCompareMask(StencilFaces.Front, ~0);
     CommandBuffer.CmdSetStencilReference(StencilFaces.Front, 1);
     CommandBuffer.CmdSetStencilWriteMask(StencilFaces.Front, ~0);
     CommandBuffer.End();
 }
Exemple #14
0
 public void CmdWriteTimestamp()
 {
     using (QueryPool queryPool = Device.CreateQueryPool(new QueryPoolCreateInfo(QueryType.Timestamp, 1)))
     {
         CommandBuffer.Begin();
         CommandBuffer.CmdWriteTimestamp(PipelineStages.AllCommands, queryPool, 0);
         CommandBuffer.End();
     }
 }
Exemple #15
0
 public void CmdResetQueryPool()
 {
     using (QueryPool queryPool = Device.CreateQueryPool(new QueryPoolCreateInfo(QueryType.Timestamp, 1)))
     {
         CommandBuffer.Begin();
         CommandBuffer.CmdResetQueryPool(queryPool, 0, 1);
         CommandBuffer.End();
     }
 }
Exemple #16
0
 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();
     }
 }
Exemple #17
0
 public void CmdSetAndResetEvent()
 {
     using (Event evt = Device.CreateEvent())
     {
         CommandBuffer.Begin();
         CommandBuffer.CmdSetEvent(evt, PipelineStages.AllCommands);
         CommandBuffer.CmdResetEvent(evt, PipelineStages.AllCommands);
         CommandBuffer.End();
     }
 }
Exemple #18
0
 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();
     }
 }
Exemple #19
0
        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();
        }
Exemple #20
0
 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();
         }
 }
Exemple #21
0
            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();
            }
Exemple #22
0
        public override void Draw(ApplicationTime time)
        {
            Device.WaitIdle();

            CommandBuffer.Begin();
            CommandBuffer.BeginFramebuffer(Framebuffer, r, g, b, 1);

            CommandBuffer.Close();
            Device.Submit(CommandBuffer);

            SwapChain.Present();
        }
Exemple #23
0
        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));
        }
Exemple #24
0
        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));
        }
Exemple #25
0
        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 });
        }
Exemple #26
0
        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 });
            }
        }
Exemple #28
0
        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();
                    }
        }
Exemple #29
0
        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();
        }
Exemple #30
0
        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);
        }