IMgCommandBuffer getCommandBuffer(bool begin)
{
var buffers = new IMgCommandBuffer[1];
var cmdBufAllocateInfo = new MgCommandBufferAllocateInfo
{
CommandPool = mConfiguration.Partition.CommandPool,
Level = MgCommandBufferLevel.PRIMARY,
CommandBufferCount = 1,
};
var err = mConfiguration.Device.AllocateCommandBuffers(cmdBufAllocateInfo, buffers);
Debug.Assert(err == Result.SUCCESS);
var cmdBuf = buffers[0];
if (begin)
{
var cmdBufInfo = new MgCommandBufferBeginInfo();
err = cmdBuf.BeginCommandBuffer(cmdBufInfo);
Debug.Assert(err == Result.SUCCESS);
}
return(cmdBuf);
}
public void Initialize(MgGraphicsDeviceCreateInfo createInfo)
{
mWidth = createInfo.Width;
mHeight = createInfo.Height;
mConfiguration.Initialize(mWidth, mHeight);
Debug.Assert(mConfiguration.Partition != null);
const int NO_OF_BUFFERS = 1;
var buffers = new IMgCommandBuffer[NO_OF_BUFFERS];
var pAllocateInfo = new MgCommandBufferAllocateInfo
{
CommandBufferCount = NO_OF_BUFFERS,
CommandPool = mConfiguration.Partition.CommandPool,
Level = MgCommandBufferLevel.PRIMARY,
};
mConfiguration.Device.AllocateCommandBuffers(pAllocateInfo, buffers);
var setupCmdBuffer = buffers[0];
var cmdBufInfo = new MgCommandBufferBeginInfo
{
};
var err = setupCmdBuffer.BeginCommandBuffer(cmdBufInfo);
Debug.Assert(err == Result.SUCCESS);
mGraphicsDevice.Create(setupCmdBuffer, mSwapchains, createInfo);
err = setupCmdBuffer.EndCommandBuffer();
Debug.Assert(err == Result.SUCCESS);
var submission = new[] {
new MgSubmitInfo
{
CommandBuffers = new IMgCommandBuffer[]
{
buffers[0],
},
}
};
err = mConfiguration.Queue.QueueSubmit(submission, null);
Debug.Assert(err == Result.SUCCESS);
mConfiguration.Queue.QueueWaitIdle();
mConfiguration.Device.FreeCommandBuffers(mConfiguration.Partition.CommandPool, buffers);
}
private void InitSwapchain(uint width, uint height)
{
Debug.Assert(mConfiguration.Partition != null);
const int NO_OF_BUFFERS = 1;
var buffers = new IMgCommandBuffer[NO_OF_BUFFERS];
var pAllocateInfo = new MgCommandBufferAllocateInfo
{
CommandBufferCount = NO_OF_BUFFERS,
CommandPool = mConfiguration.Partition.CommandPool,
Level = MgCommandBufferLevel.PRIMARY,
};
mConfiguration.Device.AllocateCommandBuffers(pAllocateInfo, buffers);
var createInfo = new MgGraphicsDeviceCreateInfo
{
Samples = MgSampleCountFlagBits.COUNT_1_BIT,
Color = MgFormat.R8G8B8A8_UINT,
DepthStencil = MgFormat.D24_UNORM_S8_UINT,
Width = mWidth,
Height = mHeight,
};
var setupCmdBuffer = buffers[0];
var cmdBufInfo = new MgCommandBufferBeginInfo();
var err = setupCmdBuffer.BeginCommandBuffer(cmdBufInfo);
Debug.Assert(err == Result.SUCCESS);
mGraphicsDevice.Create(setupCmdBuffer, mSwapchains, createInfo);
err = setupCmdBuffer.EndCommandBuffer();
Debug.Assert(err == Result.SUCCESS);
var submission = new[] {
new MgSubmitInfo
{
CommandBuffers = new IMgCommandBuffer[]
{
buffers[0],
},
}
};
err = mConfiguration.Queue.QueueSubmit(submission, null);
Debug.Assert(err == Result.SUCCESS);
mConfiguration.Queue.QueueWaitIdle();
mConfiguration.Device.FreeCommandBuffers(mConfiguration.Partition.CommandPool, buffers);
}
void SetupGraphicsDevice()
{
try
{
var setupCommands = new IMgCommandBuffer[1];
var pAllocateInfo = new MgCommandBufferAllocateInfo
{
CommandPool = mConfiguration.Partition.CommandPool,
CommandBufferCount = 1,
Level = MgCommandBufferLevel.PRIMARY,
};
var err = mConfiguration.Device.AllocateCommandBuffers(pAllocateInfo, setupCommands);
Debug.Assert(err == Result.SUCCESS);
var dsCreateInfo = new MgGraphicsDeviceCreateInfo
{
Color = MgFormat.B8G8R8A8_UNORM,
DepthStencil = MgFormat.D32_SFLOAT_S8_UINT,
Samples = MgSampleCountFlagBits.COUNT_1_BIT,
Width = mWidth,
Height = mHeight,
};
var cmdBuf = setupCommands[0];
var cmdBufInfo = new MgCommandBufferBeginInfo {
};
cmdBuf.BeginCommandBuffer(cmdBufInfo);
mGraphicsDevice.Create(cmdBuf, mSwapchains, dsCreateInfo);
cmdBuf.EndCommandBuffer();
var pSubmits = new MgSubmitInfo[]
{
new MgSubmitInfo
{
CommandBuffers = new IMgCommandBuffer[]
{
cmdBuf,
},
}
};
mConfiguration.Partition.Queue.QueueSubmit(pSubmits, null);
mConfiguration.Partition.Queue.QueueWaitIdle();
mConfiguration.Partition.Device.FreeCommandBuffers(
mConfiguration.Partition.CommandPool, setupCommands);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw ex;
}
}
public Result BeginCommandBuffer(MgCommandBufferBeginInfo pBeginInfo)
{
SubmissionRule = pBeginInfo.Flags;
IsQueueReady = true;
mIsRecording = true;
if ((pBeginInfo.Flags & MgCommandBufferUsageFlagBits.RENDER_PASS_CONTINUE_BIT)
!= MgCommandBufferUsageFlagBits.RENDER_PASS_CONTINUE_BIT)
{
ResetAllData();
}
return(Result.SUCCESS);
}
public Result BeginCommandBuffer(MgCommandBufferBeginInfo pBeginInfo)
{
IntPtr inheritanceInfo = IntPtr.Zero;
try
{
var param_0 = new VkCommandBufferBeginInfo();
param_0.sType = VkStructureType.StructureTypeCommandBufferBeginInfo;
param_0.pNext = IntPtr.Zero;
param_0.flags = (VkCommandBufferUsageFlags)pBeginInfo.Flags;
if (pBeginInfo.InheritanceInfo != null)
{
var ihData = new VkCommandBufferInheritanceInfo();
ihData.sType = VkStructureType.StructureTypeCommandBufferInheritanceInfo;
ihData.pNext = IntPtr.Zero;
{
UInt64 internalPtr = 0UL;
var container = pBeginInfo.InheritanceInfo.RenderPass;
if (container != null)
{
var rp = (VkRenderPass)container;
Debug.Assert(rp != null);
internalPtr = rp.Handle;
}
ihData.renderPass = internalPtr;
}
ihData.subpass = pBeginInfo.InheritanceInfo.Subpass;
{
UInt64 internalPtr = 0UL;
var container = pBeginInfo.InheritanceInfo.Framebuffer;
if (container != null)
{
var fb = (VkFramebuffer)container;
Debug.Assert(fb != null);
internalPtr = fb.Handle;
}
ihData.framebuffer = internalPtr;
}
ihData.occlusionQueryEnable = new VkBool32 {
Value = pBeginInfo.InheritanceInfo.OcclusionQueryEnable ? 1U : 0U
};
ihData.queryFlags = (VkQueryControlFlags)pBeginInfo.InheritanceInfo.QueryFlags;
ihData.pipelineStatistics = (VkQueryPipelineStatisticFlags)pBeginInfo.InheritanceInfo.PipelineStatistics;
// Copy data
inheritanceInfo = Marshal.AllocHGlobal(Marshal.SizeOf(ihData));
Marshal.StructureToPtr(ihData, inheritanceInfo, false);
}
param_0.pInheritanceInfo = inheritanceInfo;
return(Interops.vkBeginCommandBuffer(this.Handle, ref param_0));
}
finally
{
if (inheritanceInfo != IntPtr.Zero)
{
Marshal.FreeHGlobal(inheritanceInfo);
}
}
}
void buildCommandBuffers()
{
var cmdBufInfo = new MgCommandBufferBeginInfo
{
};
var renderPassBeginInfo = new MgRenderPassBeginInfo
{
RenderPass = mManager.Graphics.Renderpass,
RenderArea = new MgRect2D
{
Offset = new MgOffset2D {
X = 0, Y = 0
},
Extent = new MgExtent2D {
Width = mManager.Width,
Height = mManager.Height
},
},
ClearValues = new MgClearValue[]
{
MgClearValue.FromColorAndFormat(mManager.Swapchains.Format, new MgColor4f(0f, 0f, 0f, 0f)),
new MgClearValue {
DepthStencil = new MgClearDepthStencilValue(1024f, 0)
}
},
};
var cmdBufferCount = (uint)mManager.Graphics.Framebuffers.Length;
drawCmdBuffers = new IMgCommandBuffer[cmdBufferCount];
var cmdBufAllocateInfo = new MgCommandBufferAllocateInfo
{
CommandBufferCount = cmdBufferCount,
CommandPool = mManager.Configuration.Partition.CommandPool,
Level = MgCommandBufferLevel.PRIMARY,
};
var device = mManager.Configuration.Device;
Debug.Assert(device != null);
var err = device.AllocateCommandBuffers(cmdBufAllocateInfo, drawCmdBuffers);
Debug.Assert(err == Result.SUCCESS);
for (var i = 0; i < cmdBufferCount; ++i)
{
// Set target frame buffer
renderPassBeginInfo.Framebuffer = mManager.Graphics.Framebuffers[i];
var cmdBuf = drawCmdBuffers[i];
err = cmdBuf.BeginCommandBuffer(cmdBufInfo);
Debug.Assert(err == Result.SUCCESS);
cmdBuf.CmdBeginRenderPass(renderPassBeginInfo, MgSubpassContents.INLINE);
var viewport = new MgViewport
{
Width = mManager.Width,
Height = mManager.Height,
MinDepth = 0f,
MaxDepth = 2f,
};
cmdBuf.CmdSetViewport(0, new[] { viewport });
//var scissor = new MgRect2D {
// Extent = new MgExtent2D
// {
// Height = mManager.Height,
// Width = mManager.Width,
// },
// Offset = new MgOffset2D
// {
// X = 0,
// Y = 0,
// }
//};
cmdBuf.CmdSetScissor(0, new [] { mManager.Graphics.Scissor });
cmdBuf.CmdBindDescriptorSets(MgPipelineBindPoint.GRAPHICS, mPipelineLayout, 0, 1, mDescriptorSets, null);
cmdBuf.CmdBindPipeline(MgPipelineBindPoint.GRAPHICS, mSolidPipeline);
cmdBuf.CmdBindVertexBuffers(0, new[] { vertexBuffer.InternalBuffer }, new[] { 0UL });
cmdBuf.CmdBindIndexBuffer(indexBuffer.InternalBuffer, 0, MgIndexType.UINT32);
cmdBuf.CmdDrawIndexed(indexCount, 1, 0, 0, 0);
cmdBuf.CmdEndRenderPass();
err = cmdBuf.EndCommandBuffer();
Debug.Assert(err == Result.SUCCESS);
}
}
public void Test_GL001()
{
uint width = 600;
uint height = 400;
MgFormat format = MgFormat.R8G8B8A8_UINT;
var beginInfo = new MgCommandBufferBeginInfo {
Flags = 0,
};
cmdBuf.BeginCommandBuffer(beginInfo);
var passBeginInfo = new MgRenderPassBeginInfo
{
Framebuffer = framebuffer,
RenderPass = renderpass,
RenderArea = new MgRect2D
{
Extent = new MgExtent2D
{
Width = width,
Height = height,
},
Offset = new MgOffset2D
{
X = 0,
Y = 0,
}
},
ClearValues = new[]
{
MgClearValue.FromColorAndFormat(format, new MgColor4f(1f, 0, 1f, 1f)),
new MgClearValue {
DepthStencil = new MgClearDepthStencilValue(1f, 0),
}
},
};
cmdBuf.CmdBeginRenderPass(passBeginInfo, MgSubpassContents.INLINE);
cmdBuf.CmdBindPipeline(MgPipelineBindPoint.GRAPHICS, pipeline);
cmdBuf.CmdBindVertexBuffers(0, new[] { vertexBuffer }, new ulong[] { 0 });
cmdBuf.CmdBindIndexBuffer(indexBuffer, 0, MgIndexType.UINT32);
cmdBuf.CmdDrawIndexed(6, 1, 0, 0, 0);
cmdBuf.CmdEndRenderPass();
var err = cmdBuf.EndCommandBuffer();
var submitInfo = new[]
{
new MgSubmitInfo
{
CommandBuffers = new []
{
cmdBuf,
}
}
};
queue.QueueSubmit(submitInfo, null);
queue.QueueWaitIdle();
// MAKE SURE DOUBLE SUBMISSION WORKS
queue.QueueSubmit(submitInfo, null);
queue.QueueWaitIdle();
}
public Result BeginCommandBuffer(MgCommandBufferBeginInfo pBeginInfo)
{
throw new NotImplementedException();
}
void BuildCommandBuffers()
{
var renderPassBeginInfo = new MgRenderPassBeginInfo {
RenderPass = mGraphicsDevice.Renderpass,
RenderArea = new MgRect2D
{
Offset = new MgOffset2D {
X = 0, Y = 0
},
Extent = new MgExtent2D {
Width = mWidth, Height = mHeight
},
},
ClearValues = new MgClearValue[]
{
MgClearValue.FromColorAndFormat(mSwapchains.Format, new MgColor4f(0f, 0f, 0f, 0f)),
new MgClearValue {
DepthStencil = new MgClearDepthStencilValue(1.0f, 0)
},
},
};
for (var i = 0; i < drawCmdBuffers.Length; ++i)
{
renderPassBeginInfo.Framebuffer = mGraphicsDevice.Framebuffers[i];
var cmdBuf = drawCmdBuffers[i];
var cmdBufInfo = new MgCommandBufferBeginInfo {
};
var err = cmdBuf.BeginCommandBuffer(cmdBufInfo);
Debug.Assert(err == Result.SUCCESS);
cmdBuf.CmdBeginRenderPass(renderPassBeginInfo, MgSubpassContents.INLINE);
cmdBuf.CmdSetViewport(0,
new[] {
new MgViewport {
Height = (float)mHeight,
Width = (float)mWidth,
MinDepth = 0.0f,
MaxDepth = 1.0f,
}
}
);
cmdBuf.CmdSetScissor(0,
new[] {
new MgRect2D {
Extent = new MgExtent2D {
Width = mWidth, Height = mHeight
},
Offset = new MgOffset2D {
X = 0, Y = 0
},
}
}
);
cmdBuf.CmdBindDescriptorSets(MgPipelineBindPoint.GRAPHICS, mPipelineLayout, 0, 1, new[] { mDescriptorSet }, null);
cmdBuf.CmdBindPipeline(MgPipelineBindPoint.GRAPHICS, mPipeline);
cmdBuf.CmdBindVertexBuffers(0, new[] { vertices.buffer }, new [] { 0UL });
cmdBuf.CmdBindIndexBuffer(indices.buffer, 0, MgIndexType.UINT32);
cmdBuf.CmdDrawIndexed(indices.count, 1, 0, 0, 1);
cmdBuf.CmdEndRenderPass();
err = cmdBuf.EndCommandBuffer();
Debug.Assert(err == Result.SUCCESS);
}
}
void PrepareVertices()
{
TriangleVertex[] vertexBuffer =
{
new TriangleVertex {
position = new Vector3(1.0f, 1.0f, 0.0f),
color = new Vector3(1.0f, 0.0f, 0.0f)
},
new TriangleVertex {
position = new Vector3(-1.0f, 1.0f, 0.0f),
color = new Vector3(0.0f, 1.0f, 0.0f)
},
new TriangleVertex {
position = new Vector3(0.0f, -1.0f, 0.0f),
color = new Vector3(0.0f, 0.0f, 1.0f)
},
};
var structSize = Marshal.SizeOf(typeof(TriangleVertex));
var vertexBufferSize = (ulong)(vertexBuffer.Length * structSize);
UInt32[] indexBuffer = { 0, 1, 2 };
indices.count = (uint)indexBuffer.Length;
var indexBufferSize = indices.count * sizeof(UInt32);
var stagingBuffers = new
{
vertices = new StagingBuffer(),
indices = new StagingBuffer(),
};
{
var vertexBufferInfo = new MgBufferCreateInfo
{
Size = vertexBufferSize,
Usage = MgBufferUsageFlagBits.TRANSFER_SRC_BIT,
};
var err = mConfiguration.Device.CreateBuffer(vertexBufferInfo, null, out stagingBuffers.vertices.buffer);
Debug.Assert(err == Result.SUCCESS);
mConfiguration.Device.GetBufferMemoryRequirements(stagingBuffers.vertices.buffer, out MgMemoryRequirements memReqs);
var isValid = mConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits,
MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT | MgMemoryPropertyFlagBits.HOST_COHERENT_BIT,
out uint typeIndex);
Debug.Assert(isValid);
MgMemoryAllocateInfo memAlloc = new MgMemoryAllocateInfo
{
AllocationSize = memReqs.Size,
MemoryTypeIndex = typeIndex,
};
err = mConfiguration.Device.AllocateMemory(memAlloc, null, out stagingBuffers.vertices.memory);
Debug.Assert(err == Result.SUCCESS);
// Map and copy
err = stagingBuffers.vertices.memory.MapMemory(mConfiguration.Device, 0, memAlloc.AllocationSize, 0, out IntPtr data);
Debug.Assert(err == Result.SUCCESS);
var offset = 0;
foreach (var vertex in vertexBuffer)
{
IntPtr dest = IntPtr.Add(data, offset);
Marshal.StructureToPtr(vertex, dest, false);
offset += structSize;
}
stagingBuffers.vertices.memory.UnmapMemory(mConfiguration.Device);
stagingBuffers.vertices.buffer.BindBufferMemory(mConfiguration.Device, stagingBuffers.vertices.memory, 0);
Debug.Assert(err == Result.SUCCESS);
}
{
var vertexBufferInfo = new MgBufferCreateInfo
{
Size = vertexBufferSize,
Usage = MgBufferUsageFlagBits.VERTEX_BUFFER_BIT | MgBufferUsageFlagBits.TRANSFER_DST_BIT,
};
var err = mConfiguration.Device.CreateBuffer(vertexBufferInfo, null, out vertices.buffer);
Debug.Assert(err == Result.SUCCESS);
mConfiguration.Device.GetBufferMemoryRequirements(vertices.buffer, out MgMemoryRequirements memReqs);
var isValid = mConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits, MgMemoryPropertyFlagBits.DEVICE_LOCAL_BIT, out uint typeIndex);
Debug.Assert(isValid);
var memAlloc = new MgMemoryAllocateInfo
{
AllocationSize = memReqs.Size,
MemoryTypeIndex = typeIndex,
};
err = mConfiguration.Device.AllocateMemory(memAlloc, null, out vertices.memory);
Debug.Assert(err == Result.SUCCESS);
err = vertices.buffer.BindBufferMemory(mConfiguration.Device, vertices.memory, 0);
Debug.Assert(err == Result.SUCCESS);
}
{
var indexbufferInfo = new MgBufferCreateInfo
{
Size = indexBufferSize,
Usage = MgBufferUsageFlagBits.TRANSFER_SRC_BIT,
};
var err = mConfiguration.Device.CreateBuffer(indexbufferInfo, null, out stagingBuffers.indices.buffer);
Debug.Assert(err == Result.SUCCESS);
mConfiguration.Device.GetBufferMemoryRequirements(stagingBuffers.indices.buffer, out MgMemoryRequirements memReqs);
var isValid = mConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits,
MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT | MgMemoryPropertyFlagBits.HOST_COHERENT_BIT,
out uint typeIndex);
Debug.Assert(isValid);
var memAlloc = new MgMemoryAllocateInfo
{
AllocationSize = memReqs.Size,
MemoryTypeIndex = typeIndex,
};
err = mConfiguration.Device.AllocateMemory(memAlloc, null, out stagingBuffers.indices.memory);
Debug.Assert(err == Result.SUCCESS);
err = stagingBuffers.indices.memory.MapMemory(mConfiguration.Device, 0, indexBufferSize, 0, out IntPtr data);
Debug.Assert(err == Result.SUCCESS);
var uintBuffer = new byte[indexBufferSize];
var bufferSize = (int)indexBufferSize;
Buffer.BlockCopy(indexBuffer, 0, uintBuffer, 0, bufferSize);
Marshal.Copy(uintBuffer, 0, data, bufferSize);
stagingBuffers.indices.memory.UnmapMemory(mConfiguration.Device);
err = stagingBuffers.indices.buffer.BindBufferMemory(mConfiguration.Device, stagingBuffers.indices.memory, 0);
Debug.Assert(err == Result.SUCCESS);
}
{
var indexbufferInfo = new MgBufferCreateInfo
{
Size = indexBufferSize,
Usage = MgBufferUsageFlagBits.INDEX_BUFFER_BIT | MgBufferUsageFlagBits.TRANSFER_DST_BIT,
};
var err = mConfiguration.Device.CreateBuffer(indexbufferInfo, null, out indices.buffer);
Debug.Assert(err == Result.SUCCESS);
mConfiguration.Device.GetBufferMemoryRequirements(indices.buffer, out MgMemoryRequirements memReqs);
var isValid = mConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits, MgMemoryPropertyFlagBits.DEVICE_LOCAL_BIT, out uint typeIndex);
Debug.Assert(isValid);
var memAlloc = new MgMemoryAllocateInfo
{
AllocationSize = memReqs.Size,
MemoryTypeIndex = typeIndex,
};
err = mConfiguration.Device.AllocateMemory(memAlloc, null, out indices.memory);
Debug.Assert(err == Result.SUCCESS);
err = indices.buffer.BindBufferMemory(mConfiguration.Device, indices.memory, 0);
Debug.Assert(err == Result.SUCCESS);
}
{
var cmdBufferBeginInfo = new MgCommandBufferBeginInfo
{
};
IMgCommandBuffer copyCmd = getCommandBuffer(true);
copyCmd.CmdCopyBuffer(
stagingBuffers.vertices.buffer,
vertices.buffer,
new[]
{
new MgBufferCopy
{
Size = vertexBufferSize,
}
}
);
copyCmd.CmdCopyBuffer(stagingBuffers.indices.buffer, indices.buffer,
new[]
{
new MgBufferCopy
{
Size = indexBufferSize,
}
});
flushCommandBuffer(copyCmd);
stagingBuffers.vertices.buffer.DestroyBuffer(mConfiguration.Device, null);
stagingBuffers.vertices.memory.FreeMemory(mConfiguration.Device, null);
stagingBuffers.indices.buffer.DestroyBuffer(mConfiguration.Device, null);
stagingBuffers.indices.memory.FreeMemory(mConfiguration.Device, null);
}
const uint VERTEX_BUFFER_BIND_ID = 0;
vertices.inputBinding = new MgVertexInputBindingDescription
{
Binding = VERTEX_BUFFER_BIND_ID,
Stride = (uint)structSize,
InputRate = MgVertexInputRate.VERTEX,
};
var vertexSize = (uint)Marshal.SizeOf(typeof(Vector3));
vertices.inputAttributes = new MgVertexInputAttributeDescription[]
{
new MgVertexInputAttributeDescription
{
Binding = VERTEX_BUFFER_BIND_ID,
Location = 0,
Format = MgFormat.R32G32B32_SFLOAT,
Offset = 0,
},
new MgVertexInputAttributeDescription
{
Binding = VERTEX_BUFFER_BIND_ID,
Location = 1,
Format = MgFormat.R32G32B32_SFLOAT,
Offset = vertexSize,
}
};
vertices.inputState = new MgPipelineVertexInputStateCreateInfo
{
VertexBindingDescriptions = new MgVertexInputBindingDescription[]
{
vertices.inputBinding,
},
VertexAttributeDescriptions = vertices.inputAttributes,
};
}
void GenerateRenderingCommandBuffers()
{
var noOfFramebuffers = (uint)mGraphicsDevice.Framebuffers.Length;
var uniformStride = Marshal.SizeOf(typeof(Uniforms));
mRenderCmdBuffers = new Magnesium.IMgCommandBuffer[noOfFramebuffers];
var pAllocateInfo = new Magnesium.MgCommandBufferAllocateInfo
{
CommandPool = mConfiguration.Partition.CommandPool,
CommandBufferCount = noOfFramebuffers,
Level = Magnesium.MgCommandBufferLevel.PRIMARY,
};
var err = mConfiguration.Device.AllocateCommandBuffers(pAllocateInfo, mRenderCmdBuffers);
Debug.Assert(err == Result.SUCCESS);
for (var i = 0; i < noOfFramebuffers; ++i)
{
var cmdBuf = mRenderCmdBuffers[i];
var fb = mGraphicsDevice.Framebuffers[i];
MgCommandBufferBeginInfo pBeginInfo = new MgCommandBufferBeginInfo
{
};
// Create a new command buffer for each renderpass to the current drawable
cmdBuf.BeginCommandBuffer(pBeginInfo);
var pRenderPassBegin = new MgRenderPassBeginInfo
{
RenderPass = mGraphicsDevice.Renderpass,
Framebuffer = fb,
RenderArea = mGraphicsDevice.Scissor,
ClearValues = new MgClearValue[]
{
MgClearValue.FromColorAndFormat(mSwapchains.Format, new MgColor4f(0.5f, 0.5f, 0.5f, 0.5f)),
new MgClearValue {
DepthStencil = new MgClearDepthStencilValue {
Depth = 1f
}
},
},
};
cmdBuf.CmdBeginRenderPass(pRenderPassBegin, MgSubpassContents.INLINE);
cmdBuf.CmdBindPipeline(MgPipelineBindPoint.GRAPHICS, mPipelineState);
cmdBuf.CmdBindVertexBuffers(
0,
new IMgBuffer[]
{
mVertices.Buffer,
},
new[]
{
mVertices.Offset,
}
);
cmdBuf.CmdBindDescriptorSets(
MgPipelineBindPoint.GRAPHICS,
mPipelineLayout,
0,
1,
new[]
{
mUniformDescriptorSet,
},
new[]
{
(uint)(constantDataBufferIndex * uniformStride),
}
);
cmdBuf.CmdBindIndexBuffer(
mIndices.Buffer,
mIndices.Offset,
MgIndexType.UINT32);
cmdBuf.CmdDrawIndexed((uint)indicesVboData.Length, 1, 0, 0, 0);
//cmdBuf.CmdDrawIndexed(15, 1, 0, 0, 0);
cmdBuf.CmdEndRenderPass();
cmdBuf.EndCommandBuffer();
}
}
