private void OnDraw(VkCommandBuffer commandBuffer, VkFramebuffer framebuffer, Size size) { float g = _green + 0.001f; if (g > 1.0f) { g = 0.0f; } _green = g; VkClearValue clearValue = new VkClearValue(1.0f, _green, 0.0f, 1.0f); // Begin the render pass. VkRenderPassBeginInfo renderPassBeginInfo = new VkRenderPassBeginInfo { sType = VkStructureType.RenderPassBeginInfo, renderPass = _graphicsDevice !.Swapchain.RenderPass, framebuffer = framebuffer, renderArea = new Rectangle(size), clearValueCount = 1, pClearValues = &clearValue }; vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VkSubpassContents.Inline); vkCmdSetBlendConstants(commandBuffer, new Color4(1.0f, 1.0f, 1.0f, 1.0f)); vkCmdEndRenderPass(commandBuffer); } }
public override void ClearDepthStencil(float depth, byte stencil) { VkClearValue clearValue = new VkClearValue { depthStencil = new VkClearDepthStencilValue(depth, stencil) }; if (_activeRenderPass != VkRenderPass.Null) { VkClearAttachment clearAttachment = new VkClearAttachment { aspectMask = VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil, clearValue = clearValue }; Texture depthTex = _currentFramebuffer.DepthTarget.Value.Target; VkClearRect clearRect = new VkClearRect { baseArrayLayer = 0, layerCount = 1, rect = new VkRect2D(0, 0, depthTex.Width, depthTex.Height) }; vkCmdClearAttachments(_cb, 1, ref clearAttachment, 1, ref clearRect); } else { // Queue up the clear value for the next RenderPass. _depthClearValue = clearValue; } }
protected override void buildCommandBuffers() { var cmdBufInfo = new VkCommandBufferBeginInfo(); cmdBufInfo.sType = CommandBufferBeginInfo; var clearValues = new VkClearValue[2]; clearValues[0].color = defaultClearColor; clearValues[1].depthStencil = new VkClearDepthStencilValue(1.0f, 0); var info = new VkRenderPassBeginInfo(); info.sType = RenderPassBeginInfo; info.renderPass = renderPass; info.renderArea.offset.x = 0; info.renderArea.offset.y = 0; info.renderArea.extent.width = width; info.renderArea.extent.height = height; info.clearValues = clearValues; for (int i = 0; i < drawCmdBuffers.Length; ++i) { info.framebuffer = frameBuffers[i]; vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo); vkCmdBeginRenderPass(drawCmdBuffers[i], &info, VkSubpassContents.Inline); var viewport = new VkViewport(0, 0, width, height, 0.0f, 1.0f); vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport); var scissor = new VkRect2D(0, 0, width, height); vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor); vkCmdBindPipeline(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipeline); VkDeviceSize offsets = 0; VkBuffer buffer = vertexBuffer.buffer; vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &buffer, &offsets); vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VkIndexType.Uint32); // Render multiple objects using different model matrices by dynamically offsetting into one uniform buffer for (uint j = 0; j < OBJECT_INSTANCES; j++) { // One dynamic offset per dynamic descriptor to offset into the ubo containing all model matrices uint dynamicOffset = j * (uint)(dynamicAlignment); // Bind the descriptor set for rendering a mesh using the dynamic offset VkDescriptorSet set = descriptorSet; vkCmdBindDescriptorSets(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelineLayout, 0, 1, &set, 1, &dynamicOffset); vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0); } vkCmdEndRenderPass(drawCmdBuffers[i]); vkEndCommandBuffer(drawCmdBuffers[i]); } }
protected override void ClearColorTargetCore(uint index, RgbaFloat clearColor) { VkClearValue clearValue = new VkClearValue { color = new VkClearColorValue(clearColor.R, clearColor.G, clearColor.B, clearColor.A) }; if (_activeRenderPass != VkRenderPass.Null) { VkClearAttachment clearAttachment = new VkClearAttachment { colorAttachment = index, aspectMask = VkImageAspectFlags.Color, clearValue = clearValue }; Texture colorTex = _currentFramebuffer.ColorTargets[(int)index].Target; VkClearRect clearRect = new VkClearRect { baseArrayLayer = 0, layerCount = 1, rect = new VkRect2D(0, 0, colorTex.Width, colorTex.Height) }; vkCmdClearAttachments(_cb, 1, ref clearAttachment, 1, ref clearRect); } else { // Queue up the clear value for the next RenderPass. _clearValues[index] = clearValue; _validColorClearValues[index] = true; } }
private void createCommandBuffers() { int commandBuffersCount = swapChainFramebuffers.Length; commandBuffers = new VkCommandBuffer[commandBuffersCount]; VkCommandBufferAllocateInfo allocInfo = new VkCommandBufferAllocateInfo(); allocInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; allocInfo.commandPool = commandPool; allocInfo.level = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_PRIMARY; allocInfo.commandBufferCount = commandBuffersCount; VkResult result = Vulkan.vkAllocateCommandBuffers(device, allocInfo, commandBuffers); if (result != VkResult.VK_SUCCESS) { throw Program.Throw("failed to allocate command buffers!", result); } for (int i = 0; i < commandBuffersCount; i++) { VkCommandBufferBeginInfo beginInfo = new VkCommandBufferBeginInfo(); beginInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; beginInfo.flags = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; Vulkan.vkBeginCommandBuffer(commandBuffers[i], beginInfo); VkRenderPassBeginInfo renderPassInfo = new VkRenderPassBeginInfo(); renderPassInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; renderPassInfo.renderPass = renderPass; renderPassInfo.framebuffer = swapChainFramebuffers[i]; renderPassInfo.renderArea.offset = VkOffset2D.Create(0, 0); renderPassInfo.renderArea.extent = swapChainExtent; VkClearValue clearColor = VkClearValue.Create(0.01f, 0.03f, 0.01f, 1.0f); renderPassInfo.clearValueCount = 1; renderPassInfo.pClearValues = new VkClearValue[] { clearColor }; Vulkan.vkCmdBeginRenderPass(commandBuffers[i], renderPassInfo, VkSubpassContents.VK_SUBPASS_CONTENTS_INLINE); Vulkan.vkCmdBindPipeline(commandBuffers[i], VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline); VkBuffer[] vertexBuffers = new VkBuffer[] { vertexBuffer }; int[] offsets = new int[] { 0 }; Vulkan.vkCmdBindVertexBuffers(commandBuffers[i], 0, 1, vertexBuffers, offsets); Vulkan.vkCmdDraw(commandBuffers[i], vertices.Length, 1, 0, 0); Vulkan.vkCmdEndRenderPass(commandBuffers[i]); result = Vulkan.vkEndCommandBuffer(commandBuffers[i]); if (result != VkResult.VK_SUCCESS) { throw Program.Throw("failed to record command buffer!", result); } } }
protected override void buildCommandBuffers() { var cmdInfo = VkCommandBufferBeginInfo.Alloc(); var clearValues = VkClearValue.Alloc(2); clearValues[0].color = defaultClearColor; clearValues[1].depthStencil = new VkClearDepthStencilValue() { depth = 1.0f, stencil = 0 }; var info = VkRenderPassBeginInfo.Alloc(); info[0].renderPass = renderPass; info[0].renderArea.offset.x = 0; info[0].renderArea.offset.y = 0; info[0].renderArea.extent.width = width; info[0].renderArea.extent.height = height; info[0].clearValues.count = 2; info[0].clearValues.pointer = clearValues; for (int i = 0; i < drawCmdBuffers.Length; ++i) { // Set target frame buffer info[0].framebuffer = frameBuffers[i]; vkBeginCommandBuffer(drawCmdBuffers[i], cmdInfo); vkCmdBeginRenderPass(drawCmdBuffers[i], info, VkSubpassContents.Inline); VkViewport viewport = new VkViewport((float)width, (float)height, 0.0f, 1.0f); vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport); VkRect2D scissor = new VkRect2D(0, 0, width, height); vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor); { VkDescriptorSet set = descriptorSet; vkCmdBindDescriptorSets(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelineLayout, 0, 1, &set, 0, null); } vkCmdBindPipeline(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipeline); { VkDeviceSize offsets = 0; VkBuffer buffer = vertexBuffer.buffer; vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &buffer, &offsets); } vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VkIndexType.Uint32); vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0); vkCmdEndRenderPass(drawCmdBuffers[i]); vkEndCommandBuffer(drawCmdBuffers[i]); } }
private void CreateCommandBuffers() { this.commandBuffers = new VkCommandBuffer[this.swapChainFramebuffers.Length]; VkCommandBufferAllocateInfo allocInfo = new VkCommandBufferAllocateInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, commandPool = commandPool, level = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_PRIMARY, commandBufferCount = (uint)commandBuffers.Length, }; fixed(VkCommandBuffer *commandBuffersPtr = &this.commandBuffers[0]) { Helpers.CheckErrors(VulkanNative.vkAllocateCommandBuffers(this.device, &allocInfo, commandBuffersPtr)); } // Begin for (uint i = 0; i < this.commandBuffers.Length; i++) { VkCommandBufferBeginInfo beginInfo = new VkCommandBufferBeginInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, flags = 0, // Optional pInheritanceInfo = null, // Optional }; Helpers.CheckErrors(VulkanNative.vkBeginCommandBuffer(this.commandBuffers[i], &beginInfo)); // Pass VkClearValue clearColor = new VkClearValue() { color = new VkClearColorValue(0.0f, 0.0f, 0.0f, 1.0f), }; VkRenderPassBeginInfo renderPassInfo = new VkRenderPassBeginInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, renderPass = this.renderPass, framebuffer = this.swapChainFramebuffers[i], renderArea = new VkRect2D(0, 0, this.swapChainExtent.width, this.swapChainExtent.height), clearValueCount = 1, pClearValues = &clearColor, }; VulkanNative.vkCmdBeginRenderPass(this.commandBuffers[i], &renderPassInfo, VkSubpassContents.VK_SUBPASS_CONTENTS_INLINE); // Draw VulkanNative.vkCmdBindPipeline(this.commandBuffers[i], VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_GRAPHICS, this.graphicsPipeline); VulkanNative.vkCmdDraw(this.commandBuffers[i], 3, 1, 0, 0); VulkanNative.vkCmdEndRenderPass(this.commandBuffers[i]); Helpers.CheckErrors(VulkanNative.vkEndCommandBuffer(this.commandBuffers[i])); } }
private void CreateCommandBuffers() { var allocInfo = new VkCommandBufferAllocateInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, commandPool = vkCommandPool, level = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_PRIMARY, commandBufferCount = (uint)vkSwapChainFramebuffers.Length, }; vkCommandBuffers = new VkCommandBuffer[vkSwapChainFramebuffers.Length]; fixed(VkCommandBuffer *newCommandBuffer = vkCommandBuffers) VulkanNative.vkAllocateCommandBuffers(vkDevice, &allocInfo, newCommandBuffer); for (int i = 0; i < vkCommandBuffers.Length; i++) { var commandBuffer = vkCommandBuffers[i]; var beginInfo = new VkCommandBufferBeginInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, flags = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, pInheritanceInfo = null, }; var result = VulkanNative.vkBeginCommandBuffer(commandBuffer, &beginInfo); Helpers.CheckErrors(result); VkClearValue clearColor = new VkClearValue() { color = new VkClearColorValue(0, 0, 0, 1f), }; var renderPassInfo = new VkRenderPassBeginInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, renderPass = vkRenderPass, framebuffer = vkSwapChainFramebuffers[i], renderArea = new VkRect2D() { extent = vkSwapChainExtent }, pClearValues = &clearColor, clearValueCount = 1, }; VulkanNative.vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VkSubpassContents.VK_SUBPASS_CONTENTS_INLINE); VulkanNative.vkCmdBindPipeline(commandBuffer, VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_GRAPHICS, vkGraphicsPipeline); VulkanNative.vkCmdDraw(commandBuffer, 3, 1, 0, 0); VulkanNative.vkCmdEndRenderPass(commandBuffer); result = VulkanNative.vkEndCommandBuffer(commandBuffer); Helpers.CheckErrors(result); } }
public static VkClearValue Color(this VkClearValue value, VkColor color) { unsafe { value.Color.Float32[0] = color.R; value.Color.Float32[1] = color.G; value.Color.Float32[2] = color.B; value.Color.Float32[3] = color.A; } return(value); }
/// <inheritdoc /> public override void BeginDrawing(ColorRgba backgroundColor) { var clearValue = new VkClearValue(); clearValue.color.float32[0] = backgroundColor.Red; clearValue.color.float32[1] = backgroundColor.Green; clearValue.color.float32[2] = backgroundColor.Blue; clearValue.color.float32[3] = backgroundColor.Alpha; var graphicsDevice = VulkanGraphicsDevice; var graphicsSurface = graphicsDevice.GraphicsSurface; var graphicsSurfaceWidth = graphicsSurface.Width; var graphicsSurfaceHeight = graphicsSurface.Height; var renderPassBeginInfo = new VkRenderPassBeginInfo { sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, renderPass = graphicsDevice.VulkanRenderPass, framebuffer = VulkanFramebuffer, renderArea = new VkRect2D { extent = new VkExtent2D { width = (uint)graphicsSurface.Width, height = (uint)graphicsSurface.Height, }, }, clearValueCount = 1, pClearValues = &clearValue, }; var commandBuffer = VulkanCommandBuffer; vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); var viewport = new VkViewport { x = 0, y = graphicsSurface.Height, width = graphicsSurface.Width, height = -graphicsSurface.Height, minDepth = 0.0f, maxDepth = 1.0f, }; vkCmdSetViewport(commandBuffer, firstViewport: 0, viewportCount: 1, &viewport); var scissorRect = new VkRect2D { extent = new VkExtent2D { width = (uint)graphicsSurface.Width, height = (uint)graphicsSurface.Height, }, }; vkCmdSetScissor(commandBuffer, firstScissor: 0, scissorCount: 1, &scissorRect); }
/// <summary> /// Must be called outside of a renderpass scope. /// </summary> /// <param name="depthStencil"></param> /// <param name="clearValue"></param> public void ClearColor(Swapchain swapchain, uint swapchainImageIndex, VkClearColorValue clearColor) { CheckBegun(); CheckNotInRenderPass(); VkClearValue clearValue = new VkClearValue(); clearValue.color = clearColor; VkImageSubresourceRange imageRange = new VkImageSubresourceRange(); imageRange.aspectMask = VkImageAspectFlags.Color; imageRange.levelCount = 1; imageRange.layerCount = 1; vkCmdClearColorImage(vkCmd, swapchain.vkSwapchain.Images[swapchainImageIndex], VkImageLayout.General, &clearColor, 1, &imageRange); }
void CreateCommandBuffers() { if (commandBuffers != null) { commandPool.Free(commandBuffers); } var info = new VkCommandBufferAllocateInfo(); info.level = VkCommandBufferLevel.Primary; info.commandBufferCount = swapchainFramebuffers.Count; commandBuffers = new List <VkCommandBuffer>(commandPool.Allocate(info)); for (int i = 0; i < commandBuffers.Count; i++) { var buffer = commandBuffers[i]; var beginInfo = new VkCommandBufferBeginInfo(); beginInfo.flags = VkCommandBufferUsageFlags.SimultaneousUseBit; buffer.Begin(beginInfo); var renderPassInfo = new VkRenderPassBeginInfo(); renderPassInfo.renderPass = renderPass; renderPassInfo.framebuffer = swapchainFramebuffers[i]; renderPassInfo.renderArea.extent = swapchainExtent; VkClearValue clearColor = new VkClearValue { color = new VkClearColorValue(0, 0, 0, 1f) }; renderPassInfo.clearValues = new List <VkClearValue> { clearColor }; buffer.BeginRenderPass(renderPassInfo, VkSubpassContents.Inline); buffer.BindPipeline(VkPipelineBindPoint.Graphics, pipeline); buffer.BindVertexBuffers(0, new VkBuffer[] { vertexBuffer }, new long[] { 0 }); buffer.BindIndexBuffer(indexBuffer, 0, VkIndexType.UINT32); buffer.BindDescriptorSets(VkPipelineBindPoint.Graphics, pipelineLayout, 0, new VkDescriptorSet[] { descriptorSet }, null); buffer.DrawIndexed(indices.Length, 1, 0, 0, 0); buffer.EndRenderPass(); buffer.End(); } }
protected override void RecordCommandBuffer(VkCommandBuffer cmdBuffer, int imageIndex) { VkClearValue *clearValues = stackalloc VkClearValue[2]; clearValues[0] = new VkClearValue { color = new VkClearColorValue(0.39f, 0.58f, 0.93f, 1.0f) }; clearValues[1] = new VkClearValue { depthStencil = new VkClearDepthStencilValue(1.0f, 0) }; VkRenderPassBeginInfo renderPassBeginInfo = new VkRenderPassBeginInfo { sType = VkStructureType.RenderPassBeginInfo, pNext = null, framebuffer = _framebuffers[imageIndex], renderArea = new Vortice.Mathematics.Rectangle(0, 0, Host.Width, Host.Height), clearValueCount = 2, pClearValues = clearValues, renderPass = _renderPass }; vkCmdBeginRenderPass(cmdBuffer, &renderPassBeginInfo, VkSubpassContents.Inline); VkDescriptorSet descriptorSet = _descriptorSet; vkCmdBindDescriptorSets(cmdBuffer, VkPipelineBindPoint.Graphics, _pipelineLayout, 0, 1, &descriptorSet); ulong *offsets = stackalloc ulong[1] { 0 }; vkCmdBindPipeline(cmdBuffer, VkPipelineBindPoint.Graphics, _pipeline); VkBuffer buffer = _cubeVertices.Buffer; vkCmdBindVertexBuffers(cmdBuffer, 0, 1, &buffer, offsets); vkCmdBindIndexBuffer(cmdBuffer, _cubeIndices.Buffer, 0, VkIndexType.Uint32); vkCmdDrawIndexed(cmdBuffer, (uint)_cubeIndices.Count, 1, 0, 0, 0); vkCmdEndRenderPass(cmdBuffer); }
private void OnDraw(VkCommandBuffer commandBuffer, VkFramebuffer framebuffer, Size size) { VkClearValue clearValue = new VkClearValue(new Color4(0.1f, 0.1f, 0.2f, 1.0f)); // Begin the render pass. VkRenderPassBeginInfo renderPassBeginInfo = new VkRenderPassBeginInfo { sType = VkStructureType.RenderPassBeginInfo, renderPass = _graphicsDevice.Swapchain.RenderPass, framebuffer = framebuffer, renderArea = new Rectangle(size.Width, size.Height), clearValueCount = 1, pClearValues = &clearValue }; vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VkSubpassContents.Inline); vkCmdEndRenderPass(commandBuffer); }
void CreateCommandBuffers() { if (commandBuffers != null) { commandPool.Free(commandBuffers); } var info = new VkCommandBufferAllocateInfo(); info.level = VkCommandBufferLevel.Primary; info.commandBufferCount = swapchainFramebuffers.Count; commandBuffers = new List <VkCommandBuffer>(commandPool.Allocate(info)); for (int i = 0; i < commandBuffers.Count; i++) { var buffer = commandBuffers[i]; var beginInfo = new VkCommandBufferBeginInfo(); beginInfo.flags = VkCommandBufferUsageFlags.SimultaneousUseBit; buffer.Begin(beginInfo); var renderPassInfo = new VkRenderPassBeginInfo(); renderPassInfo.renderPass = renderPass; renderPassInfo.framebuffer = swapchainFramebuffers[i]; renderPassInfo.renderArea.extent = swapchainExtent; VkClearValue clearColor = new VkClearValue { color = new VkClearColorValue(0, 0, 0, 1f) }; renderPassInfo.clearValues = new List <VkClearValue> { clearColor }; buffer.BeginRenderPass(renderPassInfo, VkSubpassContents.Inline); buffer.BindPipeline(VkPipelineBindPoint.Graphics, pipeline); buffer.Draw(3, 1, 0, 0); buffer.EndRenderPass(); buffer.End(); } }
public override void ClearDepthTarget(float depth) { VkClearValue clearValue = new VkClearValue { depthStencil = new VkClearDepthStencilValue(depth, 0) }; VkClearAttachment clearAttachment = new VkClearAttachment { aspectMask = VkImageAspectFlags.Depth, clearValue = clearValue }; Texture depthTex = _currentFramebuffer.DepthTexture; VkClearRect clearRect = new VkClearRect { baseArrayLayer = 0, layerCount = 1, rect = new VkRect2D(0, 0, depthTex.Width, depthTex.Height) }; vkCmdClearAttachments(_cb, 1, ref clearAttachment, 1, ref clearRect); }
protected override void ClearDepthStencilCore(float depth, byte stencil) { VkClearValue clearValue = new VkClearValue { depthStencil = new VkClearDepthStencilValue(depth, stencil) }; if (_activeRenderPass != VkRenderPass.Null) { VkImageAspectFlags aspectMask = VkImageAspectFlags.Depth; if (FormatHelpers.IsStencilFormat(_currentFramebuffer.DepthTarget.Value.Target.Format)) { aspectMask |= VkImageAspectFlags.Stencil; } VkClearAttachment clearAttachment = new VkClearAttachment { aspectMask = aspectMask, clearValue = clearValue }; Texture depthTex = _currentFramebuffer.DepthTarget.Value.Target; uint renderableWidth = _currentFramebuffer.RenderableWidth; uint renderableHeight = _currentFramebuffer.RenderableHeight; if (renderableWidth > 0 && renderableHeight > 0) { VkClearRect clearRect = new VkClearRect { baseArrayLayer = 0, layerCount = 1, rect = new VkRect2D(0, 0, renderableWidth, renderableHeight) }; vkCmdClearAttachments(_cb, 1, ref clearAttachment, 1, ref clearRect); } } else { // Queue up the clear value for the next RenderPass. _depthClearValue = clearValue; } }
public override void ClearColorTarget(uint index, RgbaFloat clearColor) { VkClearValue clearValue = new VkClearValue { color = new VkClearColorValue(clearColor.R, clearColor.G, clearColor.B, clearColor.A) }; VkClearAttachment clearAttachment = new VkClearAttachment { colorAttachment = index, aspectMask = VkImageAspectFlags.Color, clearValue = clearValue }; Texture colorTex = _currentFramebuffer.ColorTextures[(int)index]; VkClearRect clearRect = new VkClearRect { baseArrayLayer = 0, layerCount = 1, rect = new VkRect2D(0, 0, colorTex.Width, colorTex.Height) }; vkCmdClearAttachments(_cb, 1, ref clearAttachment, 1, ref clearRect); }
public void Execute(VkCommandBuffer buffer) { VkImageMemoryBarrier imageMemoryBarrier = VkImageMemoryBarrier.New(); imageMemoryBarrier.srcAccessMask = VkAccessFlags.None; imageMemoryBarrier.dstAccessMask = VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite; imageMemoryBarrier.oldLayout = VkImageLayout.Undefined; imageMemoryBarrier.newLayout = VkImageLayout.ColorAttachmentOptimal; imageMemoryBarrier.srcQueueFamilyIndex = VulkanNative.QueueFamilyIgnored; imageMemoryBarrier.dstQueueFamilyIndex = VulkanNative.QueueFamilyIgnored; imageMemoryBarrier.image = swapchainImage; imageMemoryBarrier.subresourceRange = new VkImageSubresourceRange() { baseMipLevel = 0, levelCount = 1, baseArrayLayer = 0, layerCount = 1, aspectMask = VkImageAspectFlags.Color }; vkCmdPipelineBarrier(buffer, VkPipelineStageFlags.AllGraphics, VkPipelineStageFlags.AllGraphics, VkDependencyFlags.ByRegion, 0, null, 0, null, 1, &imageMemoryBarrier); VkClearColorValue clearColorValue = new VkClearColorValue { float32_0 = 3f / 255f, float32_1 = 2f / 255, float32_2 = 12f / 255, float32_3 = 1 }; VkClearDepthStencilValue clearDepthStencilValue = new VkClearDepthStencilValue(1, 0); VkClearValue[] clearValues = new VkClearValue[2]; clearValues[0].color = clearColorValue; clearValues[1].depthStencil = clearDepthStencilValue; VkRenderPassBeginInfo passBeginInfo = VkRenderPassBeginInfo.New(); passBeginInfo.renderPass = renderPass; passBeginInfo.framebuffer = swapchainFramebuffer; passBeginInfo.renderArea.extent.width = (uint)Program.width; passBeginInfo.renderArea.extent.height = (uint)Program.height; passBeginInfo.clearValueCount = (uint)clearValues.Length; fixed(VkClearValue *ptr = clearValues) passBeginInfo.pClearValues = ptr; vkCmdBeginRenderPass(buffer, &passBeginInfo, VkSubpassContents.Inline); VkViewport viewport = new VkViewport(); viewport.x = 0; viewport.y = (float)Program.height; viewport.width = (float)Program.width; viewport.height = -(float)Program.height; VkRect2D scissor = new VkRect2D(); scissor.offset.x = 0; scissor.offset.y = 0; scissor.extent.width = (uint)Program.width; scissor.extent.height = (uint)Program.height; vkCmdSetViewport(buffer, 0, 1, &viewport); vkCmdSetScissor(buffer, 0, 1, &scissor); vkCmdBindPipeline(buffer, VkPipelineBindPoint.Graphics, pipeline); if (mesh.IsReady) { mesh.Use(); VkBuffer[] databuffers = new VkBuffer[] { mesh.Mesh.vertices.Buffer, mesh.Mesh.vertices.Buffer, mesh.Mesh.vertices.Buffer, mesh.Mesh.vertices.Buffer }; ulong[] offsets = new ulong[] { 0, 3 * 4, 6 * 4, 6 * 4 + 2 * 4 }; fixed(VkBuffer *bptr = databuffers) fixed(ulong *optr = offsets) vkCmdBindVertexBuffers(buffer, 0, 4, bptr, optr); vkCmdBindIndexBuffer(buffer, mesh.Mesh.indices.Buffer, 0, VkIndexType.Uint32); uniformdata.Write(0, camera.View.ToFloatArray()); uniformdata.Write(16, camera.Projection.ToFloatArray()); UpdateUniformData(uniformdata, swapchainImageIndex); VkDescriptorSet sets = descriptorSets[swapchainImageIndex]; VkPipelineLayout layout = pipelineLayout; vkCmdBindDescriptorSets(buffer, VkPipelineBindPoint.Graphics, layout, 0, 1, &sets, 0, null); vkCmdDrawIndexed(buffer, (uint)mesh.Mesh.indices.Length, 1, 0, 0, 0); mesh.StopUse(); } vkCmdEndRenderPass(buffer); }
// Sets up the command buffer that renders the scene to the offscreen frame buffer void buildOffscreenCommandBuffer() { if (offscreenPass.commandBuffer.handle == 0) { offscreenPass.commandBuffer = createCommandBuffer( VkCommandBufferLevel.Primary //VK_COMMAND_BUFFER_LEVEL_PRIMARY , false); } if (offscreenPass.semaphore.handle == 0) { var semaphoreCreateInfo = VkSemaphoreCreateInfo.Alloc(); VkSemaphore semaphore; vkCreateSemaphore(device, semaphoreCreateInfo, null, &semaphore); offscreenPass.semaphore = semaphore; } var cmdBufInfo = VkCommandBufferBeginInfo.Alloc(); var clearValues = new VkClearValue[2]; clearValues[0].color = defaultClearColor; clearValues[1].depthStencil = new VkClearDepthStencilValue { depth = 1.0f, stencil = 0 }; var renderPassBeginInfo = VkRenderPassBeginInfo.Alloc(); renderPassBeginInfo->renderPass = offscreenPass.renderPass; renderPassBeginInfo->framebuffer = offscreenPass.framebuffer; renderPassBeginInfo->renderArea.extent.width = offscreenPass.width; renderPassBeginInfo->renderArea.extent.height = offscreenPass.height; renderPassBeginInfo->clearValues = clearValues; vkBeginCommandBuffer(offscreenPass.commandBuffer, cmdBufInfo); VkViewport viewport = new VkViewport(offscreenPass.width, offscreenPass.height, 0.0f, 1.0f); vkCmdSetViewport(offscreenPass.commandBuffer, 0, 1, &viewport); VkRect2D scissor = new VkRect2D(0, 0, offscreenPass.width, offscreenPass.height); vkCmdSetScissor(offscreenPass.commandBuffer, 0, 1, &scissor); vkCmdBeginRenderPass(offscreenPass.commandBuffer, renderPassBeginInfo, VkSubpassContents.Inline);// VK_SUBPASS_CONTENTS_INLINE); { VkDescriptorSet set = setScene; vkCmdBindDescriptorSets(offscreenPass.commandBuffer, VkPipelineBindPoint.Graphics,// VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayoutScene, 0, 1, &set, 0, null); } vkCmdBindPipeline(offscreenPass.commandBuffer, VkPipelineBindPoint.Graphics, // VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineColorPass); { VkBuffer buffer = model.vertices.buffer; VkDeviceSize offset = 0; vkCmdBindVertexBuffers(offscreenPass.commandBuffer, VERTEX_BUFFER_BIND_ID, 1, &buffer, &offset); } vkCmdBindIndexBuffer(offscreenPass.commandBuffer, model.indices.buffer, 0, VkIndexType.Uint32);// VK_INDEX_TYPE_UINT32); vkCmdDrawIndexed(offscreenPass.commandBuffer, model.indexCount, 1, 0, 0, 0); vkCmdEndRenderPass(offscreenPass.commandBuffer); vkEndCommandBuffer(offscreenPass.commandBuffer); }
protected override void buildCommandBuffers() { var cmdBufInfo = VkCommandBufferBeginInfo.Alloc(); var clearValues = new VkClearValue[2]; clearValues[0].color = defaultClearColor; clearValues[1].depthStencil = new VkClearDepthStencilValue { depth = 1.0f, stencil = 0 }; var renderPassBeginInfo = VkRenderPassBeginInfo.Alloc(); renderPassBeginInfo->renderPass = renderPass; renderPassBeginInfo->renderArea.offset.x = 0; renderPassBeginInfo->renderArea.offset.y = 0; renderPassBeginInfo->renderArea.extent.width = width; renderPassBeginInfo->renderArea.extent.height = height; //renderPassBeginInfo->clearValueCount = 2; //renderPassBeginInfo->pClearValues = &clearValues.First; renderPassBeginInfo->clearValues = clearValues; for (int i = 0; i < drawCmdBuffers.Length; ++i) { // Set target frame buffer renderPassBeginInfo->framebuffer = frameBuffers[i]; vkBeginCommandBuffer(drawCmdBuffers[i], cmdBufInfo); vkCmdBeginRenderPass(drawCmdBuffers[i], renderPassBeginInfo, VkSubpassContents.Inline);// VK_SUBPASS_CONTENTS_INLINE); VkViewport viewport = new VkViewport(width, height, 0.0f, 1.0f); vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport); VkRect2D scissor = new VkRect2D(0, 0, width, height); vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor); // 3D scene { VkDescriptorSet set = setScene; vkCmdBindDescriptorSets(drawCmdBuffers[i], VkPipelineBindPoint.Graphics,// VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayoutScene, 0, 1, &set, 0, null); } vkCmdBindPipeline(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, // VK_PIPELINE_BIND_POINT_GRAPHICS, pipelinePhongPass); { VkBuffer buffer = model.vertices.buffer; VkDeviceSize offset = 0; vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &buffer, &offset); } vkCmdBindIndexBuffer(drawCmdBuffers[i], model.indices.buffer, 0, VkIndexType.Uint32);// VK_INDEX_TYPE_UINT32); vkCmdDrawIndexed(drawCmdBuffers[i], model.indexCount, 1, 0, 0, 0); // Fullscreen triangle (clipped to a quad) with radial blur if (blur) { { VkDescriptorSet set = setRadialBlur; vkCmdBindDescriptorSets(drawCmdBuffers[i], VkPipelineBindPoint.Graphics,// VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayoutRadialBlur, 0, 1, &set, 0, null); } vkCmdBindPipeline(drawCmdBuffers[i], VkPipelineBindPoint.Graphics,// VK_PIPELINE_BIND_POINT_GRAPHICS, (displayTexture) ? pipelineOffscreenDisplay : pipelineRadialBlur); vkCmdDraw(drawCmdBuffers[i], 3, 1, 0, 0); } vkCmdEndRenderPass(drawCmdBuffers[i]); vkEndCommandBuffer(drawCmdBuffers[i]); } }
/// <summary>Begins a new frame for rendering.</summary> /// <param name="backgroundColor">A color to which the background should be cleared.</param> public void BeginFrame(ColorRgba backgroundColor) { uint frameIndex; var result = vkAcquireNextImageKHR(Device, SwapChain, timeout: ulong.MaxValue, AcquireNextImageSemaphore, fence: VK_NULL_HANDLE, &frameIndex); _frameIndex = frameIndex; if (result != VK_SUCCESS) { ThrowExternalException(nameof(vkAcquireNextImageKHR), (int)result); } var fence = Fences[frameIndex]; result = vkWaitForFences(Device, fenceCount: 1, &fence, waitAll: VK_TRUE, timeout: ulong.MaxValue); if (result != VK_SUCCESS) { ThrowExternalException(nameof(vkWaitForFences), (int)result); } result = vkResetFences(Device, 1, &fence); if (result != VK_SUCCESS) { ThrowExternalException(nameof(vkResetFences), (int)result); } var commandBufferBeginInfo = new VkCommandBufferBeginInfo { sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, pNext = null, flags = 0, pInheritanceInfo = null, }; var commandBuffer = CommandBuffers[frameIndex]; result = vkBeginCommandBuffer(commandBuffer, &commandBufferBeginInfo); if (result != VK_SUCCESS) { ThrowExternalException(nameof(vkBeginCommandBuffer), (int)result); } var clearValue = new VkClearValue { color = new VkClearColorValue { }, depthStencil = new VkClearDepthStencilValue { depth = 0.0f, stencil = 0, }, }; clearValue.color.float32[0] = backgroundColor.Red; clearValue.color.float32[1] = backgroundColor.Green; clearValue.color.float32[2] = backgroundColor.Blue; clearValue.color.float32[3] = backgroundColor.Alpha; var renderPassBeginInfo = new VkRenderPassBeginInfo { sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, pNext = null, renderPass = RenderPass, framebuffer = FrameBuffers[frameIndex], renderArea = new VkRect2D { offset = new VkOffset2D { x = 0, y = 0, }, extent = new VkExtent2D { width = (uint)_graphicsSurface.Width, height = (uint)_graphicsSurface.Height, }, }, clearValueCount = 1, pClearValues = &clearValue, }; vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); var viewport = new VkViewport { x = 0.0f, y = 0.0f, width = _graphicsSurface.Width, height = _graphicsSurface.Height, minDepth = 0.0f, maxDepth = 1.0f, }; vkCmdSetViewport(commandBuffer, firstViewport: 0, viewportCount: 1, &viewport); var scissorRect = new VkRect2D { offset = new VkOffset2D { x = 0, y = 0, }, extent = new VkExtent2D { width = (uint)_graphicsSurface.Width, height = (uint)_graphicsSurface.Height, }, }; vkCmdSetScissor(commandBuffer, firstScissor: 0, scissorCount: 1, &scissorRect); }
private void BeginCurrentRenderPass() { Debug.Assert(_activeRenderPass == VkRenderPass.Null); Debug.Assert(_currentFramebuffer != null); _currentFramebufferEverActive = true; uint attachmentCount = _currentFramebuffer.AttachmentCount; bool haveAnyAttachments = _framebuffer.ColorTargets.Count > 0 || _framebuffer.DepthTarget != null; bool haveAllClearValues = _depthClearValue.HasValue || _framebuffer.DepthTarget == null; bool haveAnyClearValues = _depthClearValue.HasValue; for (int i = 0; i < _currentFramebuffer.ColorTargets.Count; i++) { if (!_validColorClearValues[i]) { haveAllClearValues = false; haveAnyClearValues = true; } else { haveAnyClearValues = true; } } VkRenderPassBeginInfo renderPassBI = VkRenderPassBeginInfo.New(); renderPassBI.renderArea = new VkRect2D(_currentFramebuffer.RenderableWidth, _currentFramebuffer.RenderableHeight); renderPassBI.framebuffer = _currentFramebuffer.CurrentFramebuffer; if (!haveAnyAttachments || !haveAllClearValues) { renderPassBI.renderPass = _currentFramebuffer.RenderPassNoClear; vkCmdBeginRenderPass(_cb, ref renderPassBI, VkSubpassContents.Inline); _activeRenderPass = _currentFramebuffer.RenderPassNoClear; if (haveAnyClearValues) { if (_depthClearValue.HasValue) { ClearDepthStencil(_depthClearValue.Value.depthStencil.depth, (byte)_depthClearValue.Value.depthStencil.stencil); _depthClearValue = null; } for (uint i = 0; i < _currentFramebuffer.ColorTargets.Count; i++) { if (_validColorClearValues[i]) { _validColorClearValues[i] = false; VkClearValue vkClearValue = _clearValues[i]; RgbaFloat clearColor = new RgbaFloat( vkClearValue.color.float32_0, vkClearValue.color.float32_1, vkClearValue.color.float32_2, vkClearValue.color.float32_3); ClearColorTarget(i, clearColor); } } } } else { // We have clear values for every attachment. renderPassBI.renderPass = _currentFramebuffer.RenderPassClear; fixed(VkClearValue *clearValuesPtr = &_clearValues[0]) { renderPassBI.clearValueCount = attachmentCount; renderPassBI.pClearValues = clearValuesPtr; if (_depthClearValue.HasValue) { _clearValues[_currentFramebuffer.ColorTargets.Count] = _depthClearValue.Value; } vkCmdBeginRenderPass(_cb, ref renderPassBI, VkSubpassContents.Inline); _activeRenderPass = _currentFramebuffer.RenderPassClear; Util.ClearArray(_validColorClearValues); } } // Set new image layouts foreach (FramebufferAttachment colorTarget in _currentFramebuffer.ColorTargets) { VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(colorTarget.Target); VkImageLayout layout = (vkTex.Usage & TextureUsage.Sampled) != 0 ? VkImageLayout.ShaderReadOnlyOptimal : VkImageLayout.ColorAttachmentOptimal; vkTex.SetImageLayout(colorTarget.ArrayLayer, layout); } if (_currentFramebuffer.DepthTarget != null) { VkTexture vkDepthTex = Util.AssertSubtype <Texture, VkTexture>(_currentFramebuffer.DepthTarget.Value.Target); VkImageLayout layout = (vkDepthTex.Usage & TextureUsage.Sampled) != 0 ? VkImageLayout.ShaderReadOnlyOptimal : VkImageLayout.DepthStencilAttachmentOptimal; vkDepthTex.SetImageLayout(_currentFramebuffer.DepthTarget.Value.ArrayLayer, layout); } }
void CreateCommandBuffers() { if (commandBuffers != null) { var Native = new NativeArray <VkCommandBuffer>(commandBuffers); VK.FreeCommandBuffers(device, commandPool, (uint)commandBuffers.Count, Native.Address); Native.Dispose(); } commandBuffers = new List <VkCommandBuffer>(swapchainFramebuffers.Count); var info = new VkCommandBufferAllocateInfo(); info.sType = CSGL.Vulkan.VkStructureType.CommandBufferAllocateInfo; info.commandPool = commandPool; info.level = CSGL.Vulkan.VkCommandBufferLevel.Primary; info.commandBufferCount = (uint)commandBuffers.Capacity; var commandBuffersNative = new NativeArray <VkCommandBuffer>(commandBuffers.Capacity); var result = VK.AllocateCommandBuffers(device, ref info, commandBuffersNative.Address); for (int i = 0; i < commandBuffers.Capacity; i++) { commandBuffers.Add(commandBuffersNative[i]); } commandBuffersNative.Dispose(); for (int i = 0; i < commandBuffers.Count; i++) { var beginInfo = new VkCommandBufferBeginInfo(); beginInfo.sType = CSGL.Vulkan.VkStructureType.CommandBufferBeginInfo; beginInfo.flags = CSGL.Vulkan.VkCommandBufferUsageFlags.SimultaneousUseBit; VK.BeginCommandBuffer(commandBuffers[i], ref beginInfo); var renderPassInfo = new VkRenderPassBeginInfo(); renderPassInfo.sType = CSGL.Vulkan.VkStructureType.RenderPassBeginInfo; renderPassInfo.renderPass = renderPass; renderPassInfo.framebuffer = swapchainFramebuffers[i]; renderPassInfo.renderArea.extent = swapchainExtent; VkClearValue clearColor = new VkClearValue(); clearColor.color.float32_0 = 0; clearColor.color.float32_1 = 0; clearColor.color.float32_2 = 0; clearColor.color.float32_3 = 1f; var clearColorNative = new Native <VkClearValue>(clearColor); renderPassInfo.clearValueCount = 1; renderPassInfo.pClearValues = clearColorNative.Address; VK.CmdBeginRenderPass(commandBuffers[i], ref renderPassInfo, CSGL.Vulkan.VkSubpassContents.Inline); VK.CmdBindPipeline(commandBuffers[i], CSGL.Vulkan.VkPipelineBindPoint.Graphics, pipeline); VK.CmdDraw(commandBuffers[i], 3, 1, 0, 0); VK.CmdEndRenderPass(commandBuffers[i]); result = VK.EndCommandBuffer(commandBuffers[i]); clearColorNative.Dispose(); } }
protected override void buildCommandBuffers() { var cmdBufInfo = VkCommandBufferBeginInfo.Alloc(); var clearValues = new VkClearValue[2]; clearValues[0].color = defaultClearColor; clearValues[1].depthStencil = new VkClearDepthStencilValue() { depth = 1.0f, stencil = 0 }; var renderPassBeginInfo = VkRenderPassBeginInfo.Alloc(); renderPassBeginInfo->renderPass = renderPass; renderPassBeginInfo->renderArea.offset.x = 0; renderPassBeginInfo->renderArea.offset.y = 0; renderPassBeginInfo->renderArea.extent.width = width; renderPassBeginInfo->renderArea.extent.height = height; renderPassBeginInfo->clearValues = clearValues; for (int i = 0; i < drawCmdBuffers.Length; ++i) { // Set target frame buffer renderPassBeginInfo->framebuffer = frameBuffers[i]; vkBeginCommandBuffer(drawCmdBuffers[i], cmdBufInfo); vkCmdBeginRenderPass(drawCmdBuffers[i], renderPassBeginInfo, VkSubpassContents.Inline); VkViewport viewport = new VkViewport(0, 0, width, height, 0, 1); vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport); VkRect2D scissor = new VkRect2D(); scissor.extent.width = width; scissor.extent.height = height; scissor.offset.x = 0; scissor.offset.y = 0; vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor); { VkDescriptorSet set = descriptorSet; vkCmdBindDescriptorSets(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelineLayout, 0, 1, &set, 0, null); } vkCmdBindPipeline(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, wireframe ? pipelines_wireframe : pipelines_solid); ulong offsets = 0; // Bind mesh vertex buffer { VkBuffer buffer = model_vertices_buffer; VkDeviceSize offset = offsets; vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &buffer, &offset); } // Bind mesh index buffer vkCmdBindIndexBuffer(drawCmdBuffers[i], model_indices_buffer, 0, VkIndexType.Uint32); // Render mesh vertex buffer using it's indices vkCmdDrawIndexed(drawCmdBuffers[i], (uint)model_indices_count, 1, 0, 0, 0); vkCmdEndRenderPass(drawCmdBuffers[i]); vkEndCommandBuffer(drawCmdBuffers[i]); } }
internal void ClearColor(VkClearValue clearValue) { m_image.ClearColor(clearValue); }
internal void ClearDepth(VkClearValue clearValue) { m_image.ClearDepth(clearValue); }
private void BeginCurrentRenderPass() { Debug.Assert(_activeRenderPass == VkRenderPass.Null); Debug.Assert(_currentFramebuffer != null); _currentFramebufferEverActive = true; uint attachmentCount = _currentFramebuffer.AttachmentCount; bool haveAnyAttachments = _currentFramebuffer.ColorTargets.Count > 0 || _currentFramebuffer.DepthTarget != null; bool haveAllClearValues = _depthClearValue.HasValue || _currentFramebuffer.DepthTarget == null; bool haveAnyClearValues = _depthClearValue.HasValue; for (int i = 0; i < _currentFramebuffer.ColorTargets.Count; i++) { if (!_validColorClearValues[i]) { haveAllClearValues = false; haveAnyClearValues = true; } else { haveAnyClearValues = true; } } VkRenderPassBeginInfo renderPassBI = VkRenderPassBeginInfo.New(); renderPassBI.renderArea = new VkRect2D(_currentFramebuffer.RenderableWidth, _currentFramebuffer.RenderableHeight); renderPassBI.framebuffer = _currentFramebuffer.CurrentFramebuffer; if (!haveAnyAttachments || !haveAllClearValues) { renderPassBI.renderPass = _newFramebuffer ? _currentFramebuffer.RenderPassNoClear_Init : _currentFramebuffer.RenderPassNoClear_Load; vkCmdBeginRenderPass(_cb, ref renderPassBI, VkSubpassContents.Inline); _activeRenderPass = renderPassBI.renderPass; if (haveAnyClearValues) { if (_depthClearValue.HasValue) { ClearDepthStencil(_depthClearValue.Value.depthStencil.depth, (byte)_depthClearValue.Value.depthStencil.stencil); _depthClearValue = null; } for (uint i = 0; i < _currentFramebuffer.ColorTargets.Count; i++) { if (_validColorClearValues[i]) { _validColorClearValues[i] = false; VkClearValue vkClearValue = _clearValues[i]; RgbaFloat clearColor = new RgbaFloat( vkClearValue.color.float32_0, vkClearValue.color.float32_1, vkClearValue.color.float32_2, vkClearValue.color.float32_3); ClearColorTarget(i, clearColor); } } } } else { // We have clear values for every attachment. renderPassBI.renderPass = _currentFramebuffer.RenderPassClear; fixed(VkClearValue *clearValuesPtr = &_clearValues[0]) { renderPassBI.clearValueCount = attachmentCount; renderPassBI.pClearValues = clearValuesPtr; if (_depthClearValue.HasValue) { _clearValues[_currentFramebuffer.ColorTargets.Count] = _depthClearValue.Value; _depthClearValue = null; } vkCmdBeginRenderPass(_cb, ref renderPassBI, VkSubpassContents.Inline); _activeRenderPass = _currentFramebuffer.RenderPassClear; Util.ClearArray(_validColorClearValues); } } _newFramebuffer = false; }
VkCommandBuffer[] CreateCommandBuffers( VkDevice device, VkRenderPass renderPass, VkSurfaceCapabilitiesKHR surfaceCapabilities, VkImage[] images, VkFramebuffer[] framebuffers, VkPipeline pipeline, VkBuffer vertexBuffer, VkBuffer indexBuffer, uint indexLength, VkPipelineLayout pipelineLayout, VkDescriptorSet descriptorSet) { VkCommandBuffer[] buffers; { VkCommandPool pool; { var info = new VkCommandPoolCreateInfo { sType = VkStructureType.CommandPoolCreateInfo }; info.flags = VkCommandPoolCreateFlagBits.ResetCommandBuffer; //var commandPool = device.CreateCommandPool(ref poolInfo); vkCreateCommandPool(device, &info, null, &pool).Check(); } { var info = new VkCommandBufferAllocateInfo { sType = VkStructureType.CommandBufferAllocateInfo }; info.level = VkCommandBufferLevel.Primary; info.commandPool = pool; info.commandBufferCount = (uint)images.Length; //buffers = device.AllocateCommandBuffers(ref info); buffers = new VkCommandBuffer[info.commandBufferCount]; fixed(VkCommandBuffer *pointer = buffers) { vkAPI.vkAllocateCommandBuffers(device, &info, pointer).Check(); } } } var cmdBeginInfo = new VkCommandBufferBeginInfo { sType = VkStructureType.CommandBufferBeginInfo }; var clearValue = new VkClearValue { color = new VkClearColorValue(0.9f, 0.87f, 0.75f, 1.0f) }; var begin = new VkRenderPassBeginInfo { sType = VkStructureType.RenderPassBeginInfo }; begin.renderPass = renderPass; begin.clearValues = clearValue; begin.renderArea = new VkRect2D { extent = surfaceCapabilities.currentExtent }; for (int i = 0; i < images.Length; i++) { VkCommandBuffer cmds = buffers[i]; //cmds.Begin(ref cmdBeginInfo); vkAPI.vkBeginCommandBuffer(cmds, &cmdBeginInfo).Check(); begin.framebuffer = framebuffers[i]; vkAPI.vkCmdBeginRenderPass(cmds, &begin, VkSubpassContents.Inline); vkAPI.vkCmdBindDescriptorSets(cmds, VkPipelineBindPoint.Graphics, pipelineLayout, 0, 1, &descriptorSet, 0, null); vkAPI.vkCmdBindPipeline(cmds, VkPipelineBindPoint.Graphics, pipeline); VkDeviceSize offset = 0; vkAPI.vkCmdBindVertexBuffers(cmds, 0, 1, &vertexBuffer, &offset); vkAPI.vkCmdBindIndexBuffer(cmds, indexBuffer, offset, VkIndexType.Uint16); vkAPI.vkCmdDrawIndexed(cmds, indexLength, 1, 0, 0, 0); vkAPI.vkCmdEndRenderPass(cmds); vkAPI.vkEndCommandBuffer(cmds).Check(); } begin.Free(); return(buffers); }
internal void ClearDepth(VkClearValue clearValue) { Fill(m_depthData, clearValue.depthStencil.depth, m_imageExtent.width, m_imageExtent.height, m_imageExtent.width); }