コード例 #1
0
        void RenderTriangle(CommandBuffer cmdBuffer, VertexData vertexData, RenderPass renderPass, Pipeline pipeline, Framebuffer framebuffer, uint width, uint height)
        {
            // Set the viewport
            var viewport = new Viewport(0, 0, width, height, 0, 0);

            cmdBuffer.SetViewport(0, new[] { viewport });

            // Begin the render pass. Just as all commands must be issued between a Begin()
            // and End() call, certain commands can only be called bewteen BeginRenderPass()
            // and EndRenderPass()
            var renderArea      = new Rect2D(new Offset2D(0, 0), new Extent2D(width, height));
            var renderPassBegin = new RenderPassBeginInfo(renderPass, framebuffer, renderArea, null);

            cmdBuffer.BeginRenderPass(renderPassBegin, SubpassContents.Inline);
            renderPassBegin.Dispose();

            cmdBuffer.BindPipeline(PipelineBindPoint.Graphics, pipeline);

            // Render the triangle
            cmdBuffer.BindVertexBuffers(0, new[] { vertexData.Buffer }, new DeviceSize[] { 0 });
            cmdBuffer.Draw(3, 1, 0, 0);

            // End the RenderPass
            cmdBuffer.EndRenderPass();
        }
コード例 #2
0
ファイル: Functions.cs プロジェクト: jwollen/SharpVulkan
 public unsafe void BeginRenderPass(ref RenderPassBeginInfo renderPassBegin, SubpassContents contents)
 {
     fixed (RenderPassBeginInfo* __renderPassBegin__ = &renderPassBegin)
     {
         vkCmdBeginRenderPass(this, __renderPassBegin__, contents);
     }
 }
コード例 #3
0
ファイル: ClearViewSample.cs プロジェクト: slamj1/VulkanSharp
        CommandBuffer [] CreateCommandBuffers(Image [] images, Framebuffer [] framebuffers, RenderPass renderPass, SurfaceCapabilitiesKhr surfaceCapabilities)
        {
            var createPoolInfo = new CommandPoolCreateInfo {
                Flags = CommandPoolCreateFlags.ResetCommandBuffer
            };
            var commandPool = device.CreateCommandPool(createPoolInfo);
            var commandBufferAllocateInfo = new CommandBufferAllocateInfo {
                Level              = CommandBufferLevel.Primary,
                CommandPool        = commandPool,
                CommandBufferCount = (uint)images.Length
            };
            var buffers = device.AllocateCommandBuffers(commandBufferAllocateInfo);

            for (int i = 0; i < images.Length; i++)
            {
                var commandBufferBeginInfo = new CommandBufferBeginInfo();
                buffers [i].Begin(commandBufferBeginInfo);
                var renderPassBeginInfo = new RenderPassBeginInfo {
                    Framebuffer = framebuffers [i],
                    RenderPass  = renderPass,
                    ClearValues = new ClearValue [] { new ClearValue {
                                                          Color = new ClearColorValue(new float [] { 0.9f, 0.7f, 0.0f, 1.0f })
                                                      } },
                    RenderArea = new Rect2D {
                        Extent = surfaceCapabilities.CurrentExtent
                    }
                };
                buffers [i].CmdBeginRenderPass(renderPassBeginInfo, SubpassContents.Inline);
                buffers [i].CmdEndRenderPass();
                buffers [i].End();
            }
            return(buffers);
        }
コード例 #4
0
        public SwapchainManager(Device LogicalDevice, SurfaceFormatKHR SelectedSurfaceFormat)
        {
            var compositeAlpha = VulkanRenderer.Surface.SurfaceCapabilities.SupportedCompositeAlpha.HasFlag(CompositeAlphaFlagsKHR.Inherit)
               ? CompositeAlphaFlagsKHR.Inherit
               : CompositeAlphaFlagsKHR.Opaque;
            SemaphoreCreateInfo semaphoreInfo = new SemaphoreCreateInfo();

            SwapchainDrawCompleteSemaphore = LogicalDevice.CreateSemaphore(semaphoreInfo);
            CreateDefaultSwapchainRenderPass(LogicalDevice);
            renderPassBeginInfo = new RenderPassBeginInfo {
                ClearValueCount = 1, ClearValues = new ClearValue[] { new ClearValue {
                                                                          Color = new ClearColorValue(Color.AliceBlue)
                                                                      } }, RenderPass = myBaseRenderPass
            };
            renderPassBeginInfo.RenderArea = new Rect2D {
                Extent = new Extent2D {
                    Width = VulkanRenderer.Surface.SurfaceCapabilities.CurrentExtent.Width, Height = VulkanRenderer.Surface.SurfaceCapabilities.CurrentExtent.Height
                }, Offset = new Offset2D {
                    X = 0, Y = 0
                }
            };
            var swapchainInfo = new SwapchainCreateInfoKHR
            {
                Surface            = VulkanRenderer.Surface,
                MinImageCount      = VulkanRenderer.Surface.SurfaceCapabilities.MinImageCount + 1,
                ImageFormat        = VulkanRenderer.Surface.SelectedSurfaceFormat.Format,
                ImageColorSpace    = VulkanRenderer.Surface.SelectedSurfaceFormat.ColorSpace,
                ImageExtent        = VulkanRenderer.Surface.SurfaceCapabilities.CurrentExtent,
                ImageUsage         = ImageUsageFlags.ColorAttachment,
                PreTransform       = SurfaceTransformFlagsKHR.Identity,
                ImageArrayLayers   = 1,
                ImageSharingMode   = SharingMode.Exclusive,
                QueueFamilyIndices = new uint[] { VulkanRenderer.ActiveGraphicsFamilyQueueIndex },
                PresentMode        = PresentModeKHR.Fifo,
                CompositeAlpha     = compositeAlpha
            };

            Swapchain            = VulkanRenderer.SelectedLogicalDevice.CreateSwapchainKHR(swapchainInfo);
            Images               = VulkanRenderer.SelectedLogicalDevice.GetSwapchainImagesKHR(Swapchain);
            SwapChainPresentInfo = new PresentInfoKHR
            {
                Swapchains   = new SwapchainKHR[] { Swapchain },
                ImageIndices = new uint[] { VulkanRenderer.SelectedLogicalDevice.AcquireNextImageKHR(Swapchain, ulong.MaxValue, SwapchainDrawCompleteSemaphore) }
            };


            Framebuffers = new SwapChainFrameBuffer[Images.Length]; //Move this to swap chains

            for (int i = 0; i < Images.Length; i++)
            {
                Framebuffers[i] = new SwapChainFrameBuffer(myBaseRenderPass, Images[i], i, VulkanRenderer.Surface.SurfaceCapabilities.CurrentExtent.Width, VulkanRenderer.Surface.SurfaceCapabilities.CurrentExtent.Height, 1);
                Framebuffers[i].Initialize();
            }
        }
コード例 #5
0
        protected override void RecordCommandBuffer(CommandBuffer cmdBuffer, int imageIndex)
        {
            var renderPassBeginInfo = new RenderPassBeginInfo(
                _framebuffers[imageIndex],
                new Rect2D(Offset2D.Zero, new Extent2D(Host.Width, Host.Height)),
                new ClearColorValue(new ColorF4(0.39f, 0.58f, 0.93f, 1.0f)));

            cmdBuffer.CmdBeginRenderPass(renderPassBeginInfo);
            cmdBuffer.CmdBindPipeline(PipelineBindPoint.Graphics, _pipeline);
            cmdBuffer.CmdDraw(3);
            cmdBuffer.CmdEndRenderPass();
        }
コード例 #6
0
        public void BeginPass(PipelineController pipeline)
        {
            var renderPassBeginInfo = new RenderPassBeginInfo(
                Image.GetFrameBuffer(pipeline),
                new Rect2D(0, 0, Image.Size.X, Image.Size.Y),
                new ClearColorValue(),
                new ClearDepthStencilValue(1f, 0)
                );

            CommandBuffer.CmdBeginRenderPass(renderPassBeginInfo);
            CommandBuffer.CmdBindDescriptorSet(PipelineBindPoint.Graphics, pipeline.PipelineLayout, pipeline.DescriptorSet);
            CommandBuffer.CmdBindPipeline(PipelineBindPoint.Graphics, pipeline.Pipeline);
        }
コード例 #7
0
        protected override void RecordCommandBuffer(CommandBuffer cmdBuffer, int imageIndex)
        {
            var renderPassBeginInfo = new RenderPassBeginInfo(
                _framebuffers[imageIndex],
                new Rect2D(0, 0, Host.Width, Host.Height),
                new ClearColorValue(new ColorF4(0.39f, 0.58f, 0.93f, 1.0f)),
                new ClearDepthStencilValue(1.0f, 0));

            cmdBuffer.CmdBeginRenderPass(renderPassBeginInfo);
            cmdBuffer.CmdBindDescriptorSet(PipelineBindPoint.Graphics, _pipelineLayout, _descriptorSet);
            cmdBuffer.CmdBindPipeline(PipelineBindPoint.Graphics, _pipeline);
            cmdBuffer.CmdBindVertexBuffer(_cubeVertices);
            cmdBuffer.CmdBindIndexBuffer(_cubeIndices);
            cmdBuffer.CmdDrawIndexed(_cubeIndices.Count);
            cmdBuffer.CmdEndRenderPass();
        }
コード例 #8
0
        private void CreateCommandBuffers()
        {
            var allocInfo = new CommandBufferAllocateInfo()
            {
                CommandPool        = vkCommandPool,
                Level              = CommandBufferLevel.Primary,
                CommandBufferCount = (uint)vkSwapChainFramebuffers.Length,
            };

            vkCommandBuffers = vkDevice.AllocateCommandBuffers(allocInfo);

            for (int i = 0; i < vkCommandBuffers.Length; i++)
            {
                var beginInfo = new CommandBufferBeginInfo()
                {
                    Flags           = CommandBufferUsageFlags.SimultaneousUse,
                    InheritanceInfo = null,
                };

                var buffer = vkCommandBuffers[i];
                buffer.Begin(beginInfo);

                var renderPassInfo = new RenderPassBeginInfo()
                {
                    RenderPass  = vkRenderPass,
                    Framebuffer = vkSwapChainFramebuffers[i],
                    RenderArea  = new Rect2D()
                    {
                        Extent = vkSwapChainExtent
                    },
                    ClearValues = new ClearValue[] { new ClearValue()
                                                     {
                                                         Color = new ClearColorValue(new float[] { 0.0f, 0.0f, 0.0f, 1.0f })
                                                     } },
                };

                buffer.CmdBeginRenderPass(renderPassInfo, SubpassContents.Inline);
                buffer.CmdBindPipeline(PipelineBindPoint.Graphics, vkGraphicsPipeline);
                buffer.CmdBindDescriptorSet(PipelineBindPoint.Graphics, vkPipelineLayout, 0, vkDescriptorSet, 0);
                buffer.CmdBindVertexBuffer(0, vkVertexBuffer, 0);
                buffer.CmdBindIndexBuffer(vkIndexBuffer, 0, IndexType.Uint16);
                buffer.CmdDrawIndexed((uint)indices.Length, 1, 0, 0, 0);
                buffer.CmdEndRenderPass();
                buffer.End();
            }
        }
コード例 #9
0
        protected override void InitCommandBuffers()
        {
            for (int i = 0; i < bufferSize; i++)
            {
                var beginInfo = new CommandBufferBeginInfo
                {
                    Flags = CommandBufferUsageFlags.SimultaneousUse
                };
                commandBuffers[i].Begin(beginInfo);

                var clearColor = new ClearValue
                {
                    Color = new ClearColorValue(new float[] { 25 / 255f, 0.0f, 10 / 255f, 1.0f })
                };
                var renderPassInfo = new RenderPassBeginInfo
                {
                    RenderPass  = renderPass,
                    Framebuffer = framebuffers[i],
                    RenderArea  = new Rect2D
                    {
                        Offset = new Offset2D
                        {
                            X = 0,
                            Y = 0
                        },
                        Extent = extent
                    },
                    ClearValueCount = 1,
                    ClearValues     = new ClearValue[] { clearColor }
                };
                commandBuffers[i].CmdBeginRenderPass(renderPassInfo, SubpassContents.Inline);
                commandBuffers[i].CmdBindPipeline(PipelineBindPoint.Graphics, graphicsPipeline);

                commandBuffers[i].CmdBindVertexBuffer(0, vertexBuffer, 0);
                commandBuffers[i].CmdBindIndexBuffer(indexBuffer, 0, IndexType.Uint32);

                commandBuffers[i].CmdBindDescriptorSet(PipelineBindPoint.Graphics, pipelineLayout, 0, descriptorSets[i], null);

                commandBuffers[i].CmdDrawIndexed((uint)mesh.indices.Length, 1, 0, 0, 0);

                commandBuffers[i].CmdEndRenderPass();
                commandBuffers[i].End();
            }
        }
コード例 #10
0
ファイル: PipeLine.cs プロジェクト: Kharzette/GrogLibsCore
        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);
        }
コード例 #11
0
        public GeometryPass(GeometryBuffer myBuffer, RenderPass OffscreenRenderPass, SecondaryCommandBufferPool mySecondaryCommandPool, ShaderManager myShaderManager) : base(mySecondaryCommandPool, "GeometryPass")
        {
            this.myShaderManager  = myShaderManager;
            myRenderpassBeginInfo = new RenderPassBeginInfo
            {
                ClearValueCount = 4,
                ClearValues     = new ClearValue[]
                {
                    new ClearValue {
                        Color = new ClearColorValue(Color.AliceBlue)
                    },                                                               //TODO: Always remember to match these!
                    new ClearValue {
                        Color = new ClearColorValue(Color.AliceBlue)
                    },                                                               //TODO: Always remember to match these!
                    new ClearValue {
                        Color = new ClearColorValue(Color.AliceBlue)
                    },                                                               //TODO: Always remember to match these!
                    new ClearValue {
                        DepthStencil = new ClearDepthStencilValue()
                        {
                            Depth = 1.0f, Stencil = 0
                        }
                    }
                },
                RenderPass = OffscreenRenderPass,
                RenderArea = new Rect2D {
                    Extent = new Extent2D {
                        Width = VulkanRenderer.Surface.SurfaceCapabilities.CurrentExtent.Width, Height = VulkanRenderer.Surface.SurfaceCapabilities.CurrentExtent.Height
                    }, Offset = new Offset2D {
                        X = 0, Y = 0
                    }
                },
            };
            myBackbuffer = myBuffer;
            myRenderpassBeginInfo.Framebuffer = myBackbuffer;
            String[] ShaderNames = { "GBufferPassVertex", "GBufferPassFragment" };
            Tuple <PipelineLayout, Pipeline> myPipelineDefault = myShaderManager.CreatePipeline(OffscreenRenderPass, ShaderNames, out ExpectedModelSet);

            myActivePipelines.Add("Default", myPipelineDefault);
            this.OffscreenRenderPass = OffscreenRenderPass;
        }
コード例 #12
0
        void RenderTexturedQuad(CommandBuffer cmdBuffer, VertexData vertexData, ImageData imageData, PipelineLayout pipelineLayout, DescriptorSet descriptorSet, RenderPass renderPass, Pipeline pipeline, Framebuffer framebuffer, uint width, uint height)
        {
            var viewport = new Viewport(0, 0, width, height, 0, 1);

            cmdBuffer.SetViewport(0, new[] { viewport });

            var renderArea      = new Rect2D(new Offset2D(0, 0), new Extent2D(width, height));
            var renderPassBegin = new RenderPassBeginInfo(renderPass, framebuffer, renderArea, null);

            cmdBuffer.BeginRenderPass(renderPassBegin, SubpassContents.Inline);
            renderPassBegin.Dispose();

            cmdBuffer.BindDescriptorSets(PipelineBindPoint.Graphics, pipelineLayout, 0, new[] { descriptorSet }, null);

            cmdBuffer.BindPipeline(PipelineBindPoint.Graphics, pipeline);

            cmdBuffer.BindVertexBuffers(0, new[] { vertexData.Buffer }, new DeviceSize[] { 0 });
            cmdBuffer.BindIndexBuffer(vertexData.IndexBuffer, 0, IndexType.Uint32);
            cmdBuffer.DrawIndexed((uint)vertexData.Indicies.Length, 1, 0, 0, 1);

            cmdBuffer.EndRenderPass();
        }
コード例 #13
0
ファイル: XLogoView.cs プロジェクト: iwandi/VulkanSharp
        CommandBuffer [] CreateCommandBuffers(Image [] images, Framebuffer [] framebuffers, Pipeline pipeline, Buffer vertexBuffer, Buffer indexBuffer, uint indexLength)
        {
            var createPoolInfo = new CommandPoolCreateInfo {
                Flags = CommandPoolCreateFlags.ResetCommandBuffer
            };
            var commandPool = device.CreateCommandPool(createPoolInfo);
            var commandBufferAllocateInfo = new CommandBufferAllocateInfo {
                Level              = CommandBufferLevel.Primary,
                CommandPool        = commandPool,
                CommandBufferCount = (uint)images.Length
            };
            var buffers = device.AllocateCommandBuffers(commandBufferAllocateInfo);
            var commandBufferBeginInfo = new CommandBufferBeginInfo();

            for (int i = 0; i < images.Length; i++)
            {
                buffers [i].Begin(commandBufferBeginInfo);
                var renderPassBeginInfo = new RenderPassBeginInfo {
                    Framebuffer = framebuffers [i],
                    RenderPass  = renderPass,
                    ClearValues = new ClearValue [] { new ClearValue {
                                                          Color = new ClearColorValue(new float [] { 0.9f, 0.87f, 0.75f, 1.0f })
                                                      } },
                    RenderArea = new Rect2D {
                        Extent = surfaceCapabilities.CurrentExtent
                    }
                };
                buffers [i].CmdBeginRenderPass(renderPassBeginInfo, SubpassContents.Inline);
                buffers [i].CmdBindDescriptorSets(PipelineBindPoint.Graphics, pipelineLayout, 0, descriptorSets, null);
                buffers [i].CmdBindPipeline(PipelineBindPoint.Graphics, pipeline);
                buffers [i].CmdBindVertexBuffers(0, new Buffer [] { vertexBuffer }, new DeviceSize [] { 0 });
                buffers [i].CmdBindIndexBuffer(indexBuffer, 0, IndexType.Uint16);
                buffers [i].CmdDrawIndexed(indexLength, 1, 0, 0, 0);
                buffers [i].CmdEndRenderPass();
                buffers [i].End();
            }

            return(buffers);
        }
コード例 #14
0
        void RenderTriangle(CommandBuffer cmdBuffer, VertexData vertexData, RenderPass renderPass, Framebuffer framebuffer, Pipeline pipeline, uint width, uint height)
        {
            // Set the viewport
            var viewport = new Viewport(0, 0, width, height, 0, 0);

            cmdBuffer.SetViewport(0, new[] { viewport });

            var renderArea      = new Rect2D(new Offset2D(0, 0), new Extent2D(width, height));
            var renderPassBegin = new RenderPassBeginInfo(renderPass, framebuffer, renderArea, null);

            cmdBuffer.BeginRenderPass(renderPassBegin, SubpassContents.Inline);
            renderPassBegin.Dispose();

            cmdBuffer.BindPipeline(PipelineBindPoint.Graphics, pipeline);

            // Render the triangle
            cmdBuffer.BindVertexBuffers(0, new[] { vertexData.Buffer }, new DeviceSize[] { 0 });
            cmdBuffer.Draw(3, 1, 0, 0);

            // End the RenderPass
            cmdBuffer.EndRenderPass();
        }
コード例 #15
0
        public static void RecordCommandBuffer(CommandBuffer cmdBuffer, int imgIndex)
        {
            Context             c     = forge.Context(0);
            RenderPassBeginInfo bInfo = new RenderPassBeginInfo(
                c.framebuffers[imgIndex],
                c.pass,
                new Rect2D(0, 0, c.width, c.height),
                new ClearColorValue(new ColorF4(.8f, .2f, .4f, 1)),
                new ClearDepthStencilValue(1, 0));

            cmdBuffer.Begin(new CommandBufferBeginInfo(CommandBufferUsages.SimultaneousUse));
            cmdBuffer.CmdBeginRenderPass(bInfo);
            cmdBuffer.CmdBindPipeline(PipelineBindPoint.Graphics, c.pipeline);
            cmdBuffer.CmdBindDescriptorSets(PipelineBindPoint.Graphics, c.pipelineLayout, 0, c.descriptorSets);
            //cmdBuffer.CmdBindVertexBuffer(c.vbo.buffer);
            //cmdBuffer.CmdBindIndexBuffer(c.index.buffer);
            cmdBuffer.CmdSetViewport(new Viewport(0, 0, c.width, c.height));
            cmdBuffer.CmdClearColorImage(c.swapchainImages[imgIndex], ImageLayout.TransferDstOptimal, new ClearColorValue(new ColorF4(.8f, .58f, .93f, 1f)));
            //cmdBuffer.CmdDrawIndexed(c.index.count);
            cmdBuffer.CmdEndRenderPass();
            cmdBuffer.End();
        }
コード例 #16
0
ファイル: Functions.cs プロジェクト: jwollen/SharpVulkan
 internal static unsafe extern void vkCmdBeginRenderPass(CommandBuffer commandBuffer, RenderPassBeginInfo* renderPassBegin, SubpassContents contents);
コード例 #17
0
 public abstract void CmdBeginRenderPass2([Count(Count = 0)] CommandBuffer commandBuffer, [Count(Count = 0), Flow(FlowDirection.In)] ref RenderPassBeginInfo pRenderPassBegin, [Count(Count = 0), Flow(FlowDirection.In)] ref SubpassBeginInfo pSubpassBeginInfo);
コード例 #18
0
ファイル: Sample.cs プロジェクト: jwollen/SharpVulkan
        private void DrawInternal()
        {
            // Update descriptors
            var descriptorSets = stackalloc DescriptorSet[2];
            var setLayouts = stackalloc DescriptorSetLayout[2];
            setLayouts[0] = setLayouts[1] = descriptorSetLayout;

            var allocateInfo = new DescriptorSetAllocateInfo
            {
                StructureType = StructureType.DescriptorSetAllocateInfo,
                DescriptorPool = descriptorPool,
                DescriptorSetCount = 2,
                SetLayouts = new IntPtr(setLayouts),
            };
            device.AllocateDescriptorSets(ref allocateInfo, descriptorSets);

            var bufferInfo = new DescriptorBufferInfo
            {
                Buffer = uniformBuffer,
                Range = Vulkan.WholeSize
            };

            var write = new WriteDescriptorSet
            {
                StructureType = StructureType.WriteDescriptorSet,
                DescriptorCount = 1,
                DestinationSet = descriptorSets[0],
                DestinationBinding = 0,
                DescriptorType = DescriptorType.UniformBuffer,
                BufferInfo = new IntPtr(&bufferInfo)
            };

            var copy = new CopyDescriptorSet
            {
                StructureType = StructureType.CopyDescriptorSet,
                DescriptorCount = 1,
                SourceBinding = 0,
                DestinationBinding = 0,
                SourceSet = descriptorSets[0],
                DestinationSet = descriptorSets[1]
            };

            device.UpdateDescriptorSets(1, &write, 0, null);
            device.UpdateDescriptorSets(0, null, 1, &copy);

            // Post-present transition
            var memoryBarrier = new ImageMemoryBarrier
            {
                StructureType = StructureType.ImageMemoryBarrier,
                Image = backBuffers[currentBackBufferIndex],
                SubresourceRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1),
                OldLayout = ImageLayout.PresentSource,
                NewLayout = ImageLayout.ColorAttachmentOptimal,
                SourceAccessMask = AccessFlags.MemoryRead,
                DestinationAccessMask = AccessFlags.ColorAttachmentWrite
            };
            commandBuffer.PipelineBarrier(PipelineStageFlags.TopOfPipe, PipelineStageFlags.TopOfPipe, DependencyFlags.None, 0, null, 0, null, 1, &memoryBarrier);

            // Clear render target
            var clearRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1);
            commandBuffer.ClearColorImage(backBuffers[currentBackBufferIndex], ImageLayout.TransferDestinationOptimal, new RawColor4(0, 0, 0, 1), 1, &clearRange);

            // Begin render pass
            var renderPassBeginInfo = new RenderPassBeginInfo
            {
                StructureType = StructureType.RenderPassBeginInfo,
                RenderPass = renderPass,
                Framebuffer = framebuffers[currentBackBufferIndex],
                RenderArea = new Rect2D(0, 0, (uint)form.ClientSize.Width, (uint)form.ClientSize.Height),
            };
            commandBuffer.BeginRenderPass(ref renderPassBeginInfo, SubpassContents.Inline);

            // Bind pipeline
            commandBuffer.BindPipeline(PipelineBindPoint.Graphics, pipeline);

            // Bind descriptor sets
            commandBuffer.BindDescriptorSets(PipelineBindPoint.Graphics, pipelineLayout, 0, 1, descriptorSets + 1, 0, null);

            // Set viewport and scissor
            var viewport = new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height);
            commandBuffer.SetViewport(0, 1, &viewport);

            var scissor = new Rect2D(0, 0, (uint)form.ClientSize.Width, (uint)form.ClientSize.Height);
            commandBuffer.SetScissor(0, 1, &scissor);

            // Bind vertex buffer
            var vertexBufferCopy = vertexBuffer;
            ulong offset = 0;
            commandBuffer.BindVertexBuffers(0, 1, &vertexBufferCopy, &offset);

            // Draw vertices
            commandBuffer.Draw(3, 1, 0, 0);

            // End render pass
            commandBuffer.EndRenderPass();

            // Pre-present transition
            memoryBarrier = new ImageMemoryBarrier
            {
                StructureType = StructureType.ImageMemoryBarrier,
                Image = backBuffers[currentBackBufferIndex],
                SubresourceRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1),
                OldLayout = ImageLayout.ColorAttachmentOptimal,
                NewLayout = ImageLayout.PresentSource,
                SourceAccessMask = AccessFlags.ColorAttachmentWrite,
                DestinationAccessMask = AccessFlags.MemoryRead
            };
            commandBuffer.PipelineBarrier(PipelineStageFlags.AllCommands, PipelineStageFlags.BottomOfPipe, DependencyFlags.None, 0, null, 0, null, 1, &memoryBarrier);
        }
コード例 #19
0
ファイル: Sample.cs プロジェクト: jcapellman/SharpVulkan
        private void DrawInternal()
        {
            // Update descriptors
            var descriptorSets = stackalloc DescriptorSet[2];
            var setLayouts     = stackalloc DescriptorSetLayout[2];

            setLayouts[0] = setLayouts[1] = descriptorSetLayout;

            var allocateInfo = new DescriptorSetAllocateInfo
            {
                StructureType      = StructureType.DescriptorSetAllocateInfo,
                DescriptorPool     = descriptorPool,
                DescriptorSetCount = 2,
                SetLayouts         = new IntPtr(setLayouts),
            };

            device.AllocateDescriptorSets(ref allocateInfo, descriptorSets);

            var bufferInfo = new DescriptorBufferInfo
            {
                Buffer = uniformBuffer,
                Range  = Vulkan.WholeSize
            };

            var write = new WriteDescriptorSet
            {
                StructureType      = StructureType.WriteDescriptorSet,
                DescriptorCount    = 1,
                DestinationSet     = descriptorSets[0],
                DestinationBinding = 0,
                DescriptorType     = DescriptorType.UniformBuffer,
                BufferInfo         = new IntPtr(&bufferInfo)
            };

            var copy = new CopyDescriptorSet
            {
                StructureType      = StructureType.CopyDescriptorSet,
                DescriptorCount    = 1,
                SourceBinding      = 0,
                DestinationBinding = 0,
                SourceSet          = descriptorSets[0],
                DestinationSet     = descriptorSets[1]
            };

            device.UpdateDescriptorSets(1, &write, 0, null);
            device.UpdateDescriptorSets(0, null, 1, &copy);

            // Post-present transition
            var memoryBarrier = new ImageMemoryBarrier
            {
                StructureType         = StructureType.ImageMemoryBarrier,
                Image                 = backBuffers[currentBackBufferIndex],
                SubresourceRange      = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1),
                OldLayout             = ImageLayout.PresentSource,
                NewLayout             = ImageLayout.ColorAttachmentOptimal,
                SourceAccessMask      = AccessFlags.MemoryRead,
                DestinationAccessMask = AccessFlags.ColorAttachmentWrite
            };

            commandBuffer.PipelineBarrier(PipelineStageFlags.TopOfPipe, PipelineStageFlags.TopOfPipe, DependencyFlags.None, 0, null, 0, null, 1, &memoryBarrier);

            // Clear render target
            var clearRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1);

            commandBuffer.ClearColorImage(backBuffers[currentBackBufferIndex], ImageLayout.TransferDestinationOptimal, new RawColor4(0, 0, 0, 1), 1, &clearRange);

            // Begin render pass
            var renderPassBeginInfo = new RenderPassBeginInfo
            {
                StructureType = StructureType.RenderPassBeginInfo,
                RenderPass    = renderPass,
                Framebuffer   = framebuffers[currentBackBufferIndex],
                RenderArea    = new Rect2D(0, 0, (uint)form.ClientSize.Width, (uint)form.ClientSize.Height),
            };

            commandBuffer.BeginRenderPass(ref renderPassBeginInfo, SubpassContents.Inline);

            // Bind pipeline
            commandBuffer.BindPipeline(PipelineBindPoint.Graphics, pipeline);

            // Bind descriptor sets
            commandBuffer.BindDescriptorSets(PipelineBindPoint.Graphics, pipelineLayout, 0, 1, descriptorSets + 1, 0, null);

            // Set viewport and scissor
            var viewport = new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height);

            commandBuffer.SetViewport(0, 1, &viewport);

            var scissor = new Rect2D(0, 0, (uint)form.ClientSize.Width, (uint)form.ClientSize.Height);

            commandBuffer.SetScissor(0, 1, &scissor);

            // Bind vertex buffer
            var   vertexBufferCopy = vertexBuffer;
            ulong offset           = 0;

            commandBuffer.BindVertexBuffers(0, 1, &vertexBufferCopy, &offset);

            // Draw vertices
            commandBuffer.Draw(3, 1, 0, 0);

            // End render pass
            commandBuffer.EndRenderPass();

            // Pre-present transition
            memoryBarrier = new ImageMemoryBarrier
            {
                StructureType         = StructureType.ImageMemoryBarrier,
                Image                 = backBuffers[currentBackBufferIndex],
                SubresourceRange      = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1),
                OldLayout             = ImageLayout.ColorAttachmentOptimal,
                NewLayout             = ImageLayout.PresentSource,
                SourceAccessMask      = AccessFlags.ColorAttachmentWrite,
                DestinationAccessMask = AccessFlags.MemoryRead
            };
            commandBuffer.PipelineBarrier(PipelineStageFlags.AllCommands, PipelineStageFlags.BottomOfPipe, DependencyFlags.None, 0, null, 0, null, 1, &memoryBarrier);
        }
コード例 #20
0
ファイル: Tutorial03.cs プロジェクト: Benkei/Crow.Framework
        void RecordCommandBuffers()
        {
            var graphics_commandd_buffer_begin_info = new CommandBufferBeginInfo
            {
                sType            = StructureType.CommandBufferBeginInfo,             // VkStructureType                        sType
                pNext            = IntPtr.Zero,                                      // const void                            *pNext
                flags            = CommandBufferUsageFlagBits.SimultaneousUseBit,    // VkCommandBufferUsageFlagBits              flags
                pInheritanceInfo = (CommandBufferInheritanceInfo *)0                 // const VkCommandBufferInheritanceInfo  *pInheritanceInfo
            };

            var image_subresource_range = new ImageSubresourceRange
            {
                aspectMask     = ImageAspectFlagBits.ColorBit,       // VkImageAspectFlagBits             aspectMask
                baseMipLevel   = 0,                                  // uint32_t                       baseMipLevel
                layerCount     = 1,                                  // uint32_t                       levelCount
                baseArrayLayer = 0,                                  // uint32_t                       baseArrayLayer
                levelCount     = 1                                   // uint32_t                       layerCount
            };

            var clear_value = new ClearValue
            {
                color = new ClearColorValue(1.0f, 0.8f, 0.4f, 0.0f),                    // VkClearColorValue              color
            };

            ImageParameters[] swap_chain_images = GetSwapChain.Images;

            for (int i = 0; i < Vulkan.GraphicsCommandBuffers.Length; ++i)
            {
                vk.BeginCommandBuffer(Vulkan.GraphicsCommandBuffers[i], ref graphics_commandd_buffer_begin_info).CheckError();

                if (GetPresentQueue.Handle != GetGraphicsQueue.Handle)
                {
                    var barrier_from_present_to_draw = new ImageMemoryBarrier
                    {
                        sType                       = StructureType.ImageMemoryBarrier,                     // VkStructureType                sType
                        pNext                       = IntPtr.Zero,                                          // const void                    *pNext
                        sourceAccessMask            = AccessFlagBits.MemoryReadBit,                         // VkAccessFlagBits                  srcAccessMask
                        destinationAccessMask       = AccessFlagBits.ColorAttachmentWriteBit,               // VkAccessFlagBits                  dstAccessMask
                        oldLayout                   = ImageLayout.Undefined,                                // VkImageLayout                  oldLayout
                        newLayout                   = ImageLayout.PresentSourceKhr,                         // VkImageLayout                  newLayout
                        sourceQueueFamilyIndex      = GetPresentQueue.FamilyIndex,                          // uint32_t                       srcQueueFamilyIndex
                        destinationQueueFamilyIndex = GetGraphicsQueue.FamilyIndex,                         // uint32_t                       dstQueueFamilyIndex
                        image                       = swap_chain_images[i].Handle,                          // VkImage                        image
                        subresourceRange            = image_subresource_range                               // VkImageSubresourceRange        subresourceRange
                    };
                    vk.CmdPipelineBarrier(
                        Vulkan.GraphicsCommandBuffers[i],
                        PipelineStageFlagBits.ColorAttachmentOutputBit,
                        PipelineStageFlagBits.ColorAttachmentOutputBit,
                        (DependencyFlagBits)0,
                        0, (MemoryBarrier *)0,
                        0, (BufferMemoryBarrier *)0,
                        1, &barrier_from_present_to_draw);
                }

                var render_pass_begin_info = new RenderPassBeginInfo
                {
                    sType       = StructureType.RenderPassBeginInfo,               // VkStructureType                sType
                    pNext       = IntPtr.Zero,                                     // const void                    *pNext
                    renderPass  = Vulkan.RenderPass,                               // VkRenderPass                   renderPass
                    framebuffer = Vulkan.Framebuffers[i],                          // VkFramebuffer                  framebuffer
                    renderArea  = new Rect2D
                    {                                                              // VkRect2D                       renderArea
                        offset = new Offset2D
                        {                                                          // VkOffset2D                     offset
                            x = 0,                                                 // int32_t                        x
                            y = 0                                                  // int32_t                        y
                        },
                        extent = new Extent2D
                        {                                                               // VkExtent2D                     extent
                            width  = 300,                                               // int32_t                        width
                            height = 300,                                               // int32_t                        height
                        }
                    },
                    clearValueCount = 1,                                           // uint32_t                       clearValueCount
                    pClearValues    = &clear_value                                 // const VkClearValue            *pClearValues
                };

                vk.CmdBeginRenderPass(Vulkan.GraphicsCommandBuffers[i], ref render_pass_begin_info, SubpassContents.Inline);

                vk.CmdBindPipeline(Vulkan.GraphicsCommandBuffers[i], PipelineBindPoint.Graphics, Vulkan.GraphicsPipeline);

                vk.CmdDraw(Vulkan.GraphicsCommandBuffers[i], 3, 1, 0, 0);

                vk.CmdEndRenderPass(Vulkan.GraphicsCommandBuffers[i]);

                if (GetGraphicsQueue.Handle != GetPresentQueue.Handle)
                {
                    var barrier_from_draw_to_present = new ImageMemoryBarrier
                    {
                        sType                       = StructureType.ImageMemoryBarrier,                    // VkStructureType              sType
                        pNext                       = IntPtr.Zero,                                         // const void                  *pNext
                        sourceAccessMask            = AccessFlagBits.ColorAttachmentWriteBit,              // VkAccessFlagBits                srcAccessMask
                        destinationAccessMask       = AccessFlagBits.MemoryReadBit,                        // VkAccessFlagBits                dstAccessMask
                        oldLayout                   = ImageLayout.PresentSourceKhr,                        // VkImageLayout                oldLayout
                        newLayout                   = ImageLayout.PresentSourceKhr,                        // VkImageLayout                newLayout
                        sourceQueueFamilyIndex      = GetGraphicsQueue.FamilyIndex,                        // uint32_t                     srcQueueFamilyIndex
                        destinationQueueFamilyIndex = GetPresentQueue.FamilyIndex,                         // uint32_t                     dstQueueFamilyIndex
                        image                       = swap_chain_images[i].Handle,                         // VkImage                      image
                        subresourceRange            = image_subresource_range                              // VkImageSubresourceRange      subresourceRange
                    };
                    vk.CmdPipelineBarrier(
                        Vulkan.GraphicsCommandBuffers[i],
                        PipelineStageFlagBits.ColorAttachmentOutputBit,
                        PipelineStageFlagBits.BottomOfPipeBit,
                        (DependencyFlagBits)0,
                        0, (MemoryBarrier *)0,
                        0, (BufferMemoryBarrier *)0,
                        1, &barrier_from_draw_to_present);
                }
                vk.EndCommandBuffer(Vulkan.GraphicsCommandBuffers[i]).CheckError();
            }
        }
コード例 #21
0
 public void CmdBeginRenderPass(RenderPassBeginInfo pRenderPassBegin, SubpassContents contents)
 {
     unsafe {
         Interop.NativeMethods.vkCmdBeginRenderPass(this.m, pRenderPassBegin != null ? pRenderPassBegin.m : (Interop.RenderPassBeginInfo *) default(IntPtr), contents);
     }
 }