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);
}
