public void GetBufferMemoryRequirements(IMgBuffer buffer, out MgMemoryRequirements pMemoryRequirements)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
var bBuffer = (AmtBuffer)buffer;
var alignment = 16UL;
// TODO: constant buffer alignment should be 256
//if ((bBuffer.Usage & MgBufferUsageFlagBits.UNIFORM_BUFFER_BIT) == MgBufferUsageFlagBits.UNIFORM_BUFFER_BIT)
//{
// https://developer.apple.com/reference/metal/mtlrendercommandencoder/1515829-setvertexbuffer
// For buffers in the device address space, the offset must be aligned to the data type consumed by the
// vertex shader function (which is always less than or equal to 16 bytes).
// NOTE : VERTEX BUFFER data offset must be <= 16 bytes
// For buffers in the constant address space, the offset must be aligned to 256 bytes in macOS. In
// iOS, the offset must be aligned to the maximum of either the data type consumed by the vertex shader
// function, or 4 bytes.A 16 - byte alignment is always safe in iOS if you do not need to worry
// about the data type.
// NOTE : constant/uniform (i.e. readonly) buffer on macOS should be in 256 byte increments, constant on iOS
// must be >= 16 bytes or max
//}
pMemoryRequirements = new MgMemoryRequirements
{
Size = (ulong)bBuffer.Length,
MemoryTypeBits = 1 << 0,
Alignment = alignment,
};
}
public void CmdCopyBuffer(IMgBuffer srcBuffer, IMgBuffer dstBuffer, MgBufferCopy[] pRegions)
{
var bBuffer_src = (VkBuffer)srcBuffer;
Debug.Assert(bBuffer_src != null);
var bBuffer_dst = (VkBuffer)dstBuffer;
Debug.Assert(bBuffer_dst != null);
var handle = GCHandle.Alloc(pRegions, GCHandleType.Pinned);
try
{
unsafe
{
var regionCount = (uint)pRegions.Length;
var region = handle.AddrOfPinnedObject();
MgBufferCopy *regions = (MgBufferCopy *)region.ToPointer();
Interops.vkCmdCopyBuffer(this.Handle, bBuffer_src.Handle, bBuffer_dst.Handle, regionCount, regions);
}
}
finally
{
handle.Free();
}
}
public void CmdCopyBufferToImage(IMgBuffer srcBuffer, IMgImage dstImage, MgImageLayout dstImageLayout, MgBufferImageCopy[] pRegions)
{
var bSrcBuffer = (VkBuffer)srcBuffer;
Debug.Assert(bSrcBuffer != null);
var bDstImage = (VkImage)dstImage;
Debug.Assert(bDstImage != null);
var handle = GCHandle.Alloc(pRegions, GCHandleType.Pinned);
try
{
unsafe
{
var regionCount = (uint)pRegions.Length;
var region = handle.AddrOfPinnedObject();
var regions = (MgBufferImageCopy *)region.ToPointer();
Interops.vkCmdCopyBufferToImage(this.Handle, bSrcBuffer.Handle, bDstImage.Handle, dstImageLayout, regionCount, regions);
}
}
finally
{
handle.Free();
}
}
public void DispatchIndirect(IMgBuffer buffer, ulong offset)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer) + " is null");
}
var bBuffer = (AmtBuffer)buffer;
var indirect = bBuffer.VertexBuffer;
var threadsPerGroupSize = mCurrentPipeline != null ? mCurrentPipeline.ThreadsPerGroupSize : new MTLSize();
var valueItem = new AmtDispatchIndirectRecord
{
IndirectBuffer = indirect,
Offset = (nuint)offset,
ThreadsPerGroupSize = threadsPerGroupSize,
};
var nextIndex = mBag.DispatchIndirect.Push(valueItem);
mInstructions.Add(new AmtEncodingInstruction
{
Category = AmtEncoderCategory.Compute,
Index = nextIndex,
Operation = DispatchIndirect,
});
}
public BufferInfo(IMgThreadPartition partition, MgBufferUsageFlagBits usage, MgMemoryPropertyFlagBits propertyFlags, uint bufferSize)
{
Debug.Assert(partition != null);
mDevice = partition.Device;
Debug.Assert(mDevice != null);
mUsageFlags = usage;
mMemoryPropertyFlags = propertyFlags;
var bufferCreateInfo = new MgBufferCreateInfo
{
Usage = usage,
Size = bufferSize,
};
IMgBuffer buffer;
var device = partition.Device;
var result = device.CreateBuffer(bufferCreateInfo, null, out buffer);
Debug.Assert(result == Result.SUCCESS);
MgMemoryRequirements memReqs;
device.GetBufferMemoryRequirements(buffer, out memReqs);
mAlignment = memReqs.Alignment;
mBufferSize = memReqs.Size;
uint memoryTypeIndex;
partition.GetMemoryType(memReqs.MemoryTypeBits, mMemoryPropertyFlags, out memoryTypeIndex);
var memAlloc = new MgMemoryAllocateInfo
{
MemoryTypeIndex = memoryTypeIndex,
AllocationSize = memReqs.Size,
};
IMgDeviceMemory deviceMemory;
result = device.AllocateMemory(memAlloc, null, out deviceMemory);
Debug.Assert(result == Result.SUCCESS);
buffer.BindBufferMemory(device, deviceMemory, 0);
mBuffer = buffer;
mDeviceMemory = deviceMemory;
mDescriptor = new MgDescriptorBufferInfo
{
Buffer = mBuffer,
Offset = 0,
Range = mBufferSize,
};
}
public void CmdBindIndexBuffer(IMgBuffer buffer, UInt64 offset, MgIndexType indexType)
{
var bBuffer = (VkBuffer)buffer;
Debug.Assert(bBuffer != null);
Interops.vkCmdBindIndexBuffer(this.Handle, bBuffer.Handle, offset, (VkIndexType)indexType);
}
public void CmdDrawIndexedIndirect(IMgBuffer buffer, UInt64 offset, UInt32 drawCount, UInt32 stride)
{
var bBuffer = (VkBuffer)buffer;
Debug.Assert(bBuffer != null);
Interops.vkCmdDrawIndexedIndirect(this.Handle, bBuffer.Handle, offset, drawCount, stride);
}
public void CmdDispatchIndirect(IMgBuffer buffer, UInt64 offset)
{
var bBuffer = (VkBuffer)buffer;
Debug.Assert(bBuffer != null);
Interops.vkCmdDispatchIndirect(this.Handle, bBuffer.Handle, offset);
}
public void CmdUpdateBuffer(IMgBuffer dstBuffer, UInt64 dstOffset, UInt64 dataSize, IntPtr pData)
{
var bDstBuffer = (VkBuffer)dstBuffer;
Debug.Assert(bDstBuffer != null);
Interops.vkCmdUpdateBuffer(this.Handle, bDstBuffer.Handle, dstOffset, dataSize, pData);
}
public void CmdFillBuffer(IMgBuffer dstBuffer, UInt64 dstOffset, UInt64 size, UInt32 data)
{
var bDstBuffer = (VkBuffer)dstBuffer;
Debug.Assert(bDstBuffer != null);
Interops.vkCmdFillBuffer(this.Handle, bDstBuffer.Handle, dstOffset, size, data);
}
public void CmdDrawIndexedIndirect(IMgBuffer buffer, ulong offset, uint drawCount, uint stride)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
mCommandEncoder.Graphics.DrawIndexedIndirect(buffer, offset, drawCount, stride);
}
public void CmdDispatchIndirect(IMgBuffer buffer, ulong offset)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
mCommandEncoder.Compute.DispatchIndirect(buffer, offset);
}
public void GetBufferMemoryRequirements(IMgBuffer buffer, out MgMemoryRequirements pMemoryRequirements)
{
var impl = buffer as MockBuffer;
pMemoryRequirements = new MgMemoryRequirements();
if (impl != null)
{
pMemoryRequirements.MemoryTypeBits = 0;
pMemoryRequirements.Size = impl.BufferSize;
}
}
public void GetBufferMemoryRequirements(IMgBuffer buffer, out MgMemoryRequirements pMemoryRequirements)
{
var internalBuffer = buffer as IGLBuffer;
if (internalBuffer == null)
{
throw new ArgumentException(nameof(buffer));
}
uint mask = DetermineBufferMemoryType(internalBuffer.Usage);
pMemoryRequirements = new MgMemoryRequirements {
Size = internalBuffer.RequestedSize,
MemoryTypeBits = mask,
};
}
public void CmdCopyQueryPoolResults(IMgQueryPool queryPool, uint firstQuery, uint queryCount, IMgBuffer dstBuffer, ulong dstOffset, ulong stride, MgQueryResultFlagBits flags)
{
throw new NotImplementedException();
}
public void CopyBufferToImage(IMgBuffer srcBuffer, IMgImage dstImage, MgImageLayout dstImageLayout, MgBufferImageCopy[] pRegions)
{
throw new NotImplementedException();
}
public void CopyImageToBuffer(IMgImage srcImage, MgImageLayout srcImageLayout, IMgBuffer dstBuffer, MgBufferImageCopy[] pRegions)
{
throw new NotImplementedException();
}
public void CopyBuffer(IMgBuffer srcBuffer, IMgBuffer dstBuffer, MgBufferCopy[] pRegions)
{
if (srcBuffer == null)
{
throw new ArgumentNullException(nameof(srcBuffer));
}
if (dstBuffer == null)
{
throw new ArgumentNullException(nameof(dstBuffer));
}
var bSrcBuffer = (IGLBuffer)srcBuffer;
Debug.Assert(bSrcBuffer.IsBufferType);
var bDstBuffer = (IGLBuffer)dstBuffer;
Debug.Assert(bDstBuffer.IsBufferType);
var copyParams = new List <GLCmdCopyBufferRegionRecord>();
for (var i = 0; i < pRegions.Length; i += 1)
{
var region = pRegions[i];
if (region.SrcOffset > (ulong)long.MaxValue)
{
throw new InvalidOperationException(nameof(pRegions) + "[" + i + "].SrcOffset is greater than long.MaxValue");
}
if (region.DstOffset > (ulong)long.MaxValue)
{
throw new InvalidOperationException(nameof(pRegions) + "[" + i + "].DstOffset is greater than long.MaxValue");
}
if (region.Size > (ulong)int.MaxValue)
{
throw new InvalidOperationException(nameof(pRegions) + "[" + i + "].Size is greater than int.MaxValue");
}
var bufferParam = new GLCmdCopyBufferRegionRecord
{
ReadOffset = new IntPtr((long)region.SrcOffset),
WriteOffset = new IntPtr((long)region.DstOffset),
Size = (int)region.Size,
};
copyParams.Add(bufferParam);
}
var item = new GLCmdCopyBufferRecord
{
Source = bSrcBuffer.BufferId,
Destination = bDstBuffer.BufferId,
Regions = copyParams.ToArray(),
};
var nextIndex = mBag.CopyBuffers.Push(item);
var instruction = new GLCmdEncodingInstruction
{
Category = GLCmdEncoderCategory.Blit,
Index = nextIndex,
Operation = CmdCopyBuffer,
};
mInstructions.Add(instruction);
}
public void DispatchIndirect(IMgBuffer buffer, ulong offset)
{
throw new NotImplementedException();
}
public void CopyBufferToImage(IMgBuffer srcBuffer,
IMgImage dstImage, MgImageLayout dstImageLayout, MgBufferImageCopy[] pRegions)
{
if (srcBuffer == null)
{
throw new ArgumentNullException(nameof(srcBuffer));
}
if (dstImage == null)
{
throw new ArgumentNullException(nameof(dstImage));
}
if (pRegions == null)
{
throw new ArgumentNullException(nameof(pRegions));
}
var bSrcBuffer = (AmtBuffer)srcBuffer;
var bDstImage = (AmtImage)dstImage;
var regions = new List <AmtBlitCopyBufferToImageRegionRecord>();
for (var i = 0; i < pRegions.Length; ++i)
{
var currentRegion = pRegions[i];
if (currentRegion.BufferOffset > nuint.MaxValue)
{
throw new ArgumentOutOfRangeException(
"pRegions[" + i + "].BufferOffset must be less than " + nuint.MaxValue);
}
if (currentRegion.BufferRowLength > nuint.MaxValue)
{
throw new ArgumentOutOfRangeException(
"pRegions[" + i + "].DstOffset must be less than " + nuint.MaxValue);
}
var extent = currentRegion.ImageExtent;
if (extent.Width > nint.MaxValue)
{
throw new ArgumentOutOfRangeException(
"pRegions[" + i + "].ImageExtent.Width must be <=" + nint.MaxValue);
}
if (extent.Height > nint.MaxValue)
{
throw new ArgumentOutOfRangeException(
"pRegions[" + i + "].ImageExtent.Height must be <= " + nint.MaxValue);
}
if (extent.Depth > nint.MaxValue)
{
throw new ArgumentOutOfRangeException(
"pRegions[" + i + "].ImageExtent.Depth must be <= " + nint.MaxValue);
}
var sourceImageSize = currentRegion.BufferRowLength * currentRegion.BufferImageHeight;
if (sourceImageSize > nuint.MaxValue)
{
throw new ArgumentOutOfRangeException(
"sourceImageSize (pRegions[" + i
+ "].BufferRowLength * BufferImageHeight) must be <= " + nuint.MaxValue);
}
regions.Add(new AmtBlitCopyBufferToImageRegionRecord
{
BufferOffset = (nuint)currentRegion.BufferOffset,
BufferBytesPerRow = (nuint)currentRegion.BufferRowLength,
BufferImageAllocationSize = (nuint)sourceImageSize,
ImageSize = new MTLSize
{
Width = (nint)extent.Width,
Height = (nint)extent.Height,
Depth = (nint)extent.Depth,
},
BaseArrayLayer = currentRegion.ImageSubresource.BaseArrayLayer,
ImageMipLevel = currentRegion.ImageSubresource.MipLevel,
ImageLayerCount = currentRegion.ImageSubresource.LayerCount,
ImageOffset = new MTLOrigin
{
X = currentRegion.ImageOffset.X,
Y = currentRegion.ImageOffset.Y,
Z = currentRegion.ImageOffset.Z,
},
});
}
var item = new AmtBlitCopyBufferToImageRecord
{
Buffer = bSrcBuffer.VertexBuffer,
Image = bDstImage.OriginalTexture,
Regions = regions.ToArray(),
};
var nextIndex = mBag.CopyBufferToImages.Push(item);
mInstructions.Add(new AmtEncodingInstruction
{
Category = AmtEncoderCategory.Blit,
Index = nextIndex,
Operation = CmdCopyBufferToImage,
});
}
public Result CreateBuffer(MgBufferCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgBuffer pBuffer)
{
throw new NotImplementedException();
}
public void GetBufferMemoryRequirements(IMgBuffer buffer, out MgMemoryRequirements pMemoryRequirements)
{
throw new NotImplementedException();
}
static IntPtr ExtractIndirectBuffer(IMgBuffer buffer)
{
var indirectBuffer = buffer as IGLBuffer;
return((indirectBuffer != null && indirectBuffer.BufferType == GLMemoryBufferType.INDIRECT) ? indirectBuffer.Source : IntPtr.Zero);
}
public Result CreateBuffer(MgBufferCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgBuffer pBuffer)
{
pBuffer = mEntrypoint.Buffers.CreateBuffer(pCreateInfo);
return(Result.SUCCESS);
}
public void CmdCopyImageToBuffer(IMgImage srcImage, MgImageLayout srcImageLayout, IMgBuffer dstBuffer, MgBufferImageCopy[] pRegions)
{
var bSrcImage = (VkImage)srcImage;
Debug.Assert(bSrcImage != null);
var bDstBuffer = (VkBuffer)dstBuffer;
Debug.Assert(bDstBuffer != null);
var handle = GCHandle.Alloc(pRegions, GCHandleType.Pinned);
try
{
unsafe
{
var regionCount = (uint)pRegions.Length;
var regionAddress = handle.AddrOfPinnedObject();
var pinnedArray = (MgBufferImageCopy *)regionAddress.ToPointer();
Interops.vkCmdCopyImageToBuffer(this.Handle, bSrcImage.Handle, srcImageLayout, bDstBuffer.Handle, regionCount, pinnedArray);
}
}
finally
{
handle.Free();
}
}
public Result CreateBuffer(MgBufferCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgBuffer pBuffer)
{
pBuffer = new AmtBuffer(pCreateInfo);
return(Result.SUCCESS);
}
public void CmdCopyBuffer(IMgBuffer srcBuffer, IMgBuffer dstBuffer, MgBufferCopy[] pRegions)
{
throw new NotImplementedException();
}
public void Preamble()
{
// PRIVATE IMPLEMENTATION UNIT TESTING
mContainer = new Container();
mContainer.Register <IMgQueue, GLCmdQueue>(Reuse.Singleton);
mContainer.Register <IGLCmdStateRenderer, GLCmdStateRenderer>(Reuse.Singleton);
mContainer.Register <IGLCmdBlendEntrypoint, MockGLCmdBlendEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdStencilEntrypoint, MockGLCmdStencilEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdRasterizationEntrypoint, MockGLCmdRasterizationEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdDepthEntrypoint, MockGLCmdDepthEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdScissorsEntrypoint, MockGLCmdScissorsEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdDrawEntrypoint, MockGLCmdDrawEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdClearEntrypoint, MockGLCmdClearEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLErrorHandler, MockGLErrorHandler>(Reuse.Singleton);
mContainer.Register <IGLNextCmdShaderProgramCache, GLNextCmdShaderProgramCache>(Reuse.Singleton);
mContainer.Register <IGLCmdShaderProgramEntrypoint, MockGLCmdShaderProgramEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLBlitOperationEntrypoint, MockGLBlitOperationEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLSemaphoreEntrypoint, MockGLSemaphoreEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdImageEntrypoint, MockGLCmdImageEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLCmdBlitEncoder, GLCmdBlitEncoder>(Reuse.Singleton);
mContainer.Register <GLCmdBlitBag>(Reuse.Singleton);
mContainer.Register <IGLCmdComputeEncoder, GLCmdComputeEncoder>(Reuse.Singleton);
mContainer.Register <IGLCmdGraphicsEncoder, GLCmdGraphicsEncoder>(Reuse.Singleton);
mContainer.Register <GLCmdGraphicsBag>(Reuse.Singleton);
mContainer.Register <IGLCmdVBOEntrypoint, MockGLCmdVBOEntrypoint>(Reuse.Singleton);
mContainer.Register <IGLDescriptorSetBinder, GLNextDescriptorSetBinder>(Reuse.Singleton);
mContainer.Register <IGLCmdEncoderContextSorter, GLCmdIncrementalContextSorter>(Reuse.Singleton);
mContainer.Register <GLCmdCommandEncoder>(Reuse.Singleton);
mContainer.Register <GLInternalCache>(Reuse.Singleton);
mContainer.Register <IMgPipeline, GLGraphicsPipeline>(Reuse.Singleton);
mContainer.Register <IGLGraphicsPipelineCompiler, MockGLGraphicsPipelineCompiler>(Reuse.Singleton);
mContainer.Register <IGLGraphicsPipelineEntrypoint, MockGLGraphicsPipelineEntrypoint>(Reuse.Singleton);
queue = mContainer.Resolve <IMgQueue>();
var cmdEncoder = mContainer.Resolve <GLCmdCommandEncoder>();
cmdBuf = new Magnesium.OpenGL.Internals.GLCmdCommandBuffer(true, cmdEncoder);
framebuffer = new Magnesium.OpenGL.Internals.GLFramebuffer();
renderpass = new GLRenderPass(new MgAttachmentDescription[] { });
vertexBuffer = new MockGLBuffer
{
BufferId = 1,
Usage = MgBufferUsageFlagBits.VERTEX_BUFFER_BIT,
};
indexBuffer = new MockGLBuffer
{
BufferId = 2,
Usage = MgBufferUsageFlagBits.INDEX_BUFFER_BIT,
};
var layout = new MockGLPipelineLayout
{
};
mContainer.RegisterInstance <IGLPipelineLayout>(layout, Reuse.Singleton);
var blockEntries = new GLUniformBlockEntry[]
{
};
var arrayMapper = new Magnesium.OpenGL.Internals.GLInternalCacheArrayMapper(layout, blockEntries);
mContainer.RegisterInstance <GLInternalCacheArrayMapper>(arrayMapper, Reuse.Singleton);
var entrypoint = mContainer.Resolve <IGLGraphicsPipelineEntrypoint>();
var internalCache = mContainer.Resolve <GLInternalCache>();
var info = new MgGraphicsPipelineCreateInfo
{
VertexInputState = new MgPipelineVertexInputStateCreateInfo
{
VertexAttributeDescriptions = new[]
{
new MgVertexInputAttributeDescription
{
Binding = 0,
Location = 0,
Format = MgFormat.R8G8B8A8_SNORM,
}
},
VertexBindingDescriptions = new[]
{
new MgVertexInputBindingDescription
{
Binding = 0,
InputRate = MgVertexInputRate.VERTEX,
Stride = 32,
}
}
},
RasterizationState = new MgPipelineRasterizationStateCreateInfo
{
PolygonMode = MgPolygonMode.FILL,
},
InputAssemblyState = new MgPipelineInputAssemblyStateCreateInfo
{
Topology = MgPrimitiveTopology.TRIANGLE_LIST,
}
};
pipeline = new Magnesium.OpenGL.Internals.GLGraphicsPipeline(entrypoint, 1, info, internalCache, layout);
var stateRenderer = mContainer.Resolve <IGLCmdStateRenderer>();
stateRenderer.Initialize();
}
public void CmdCopyQueryPoolResults(IMgQueryPool queryPool, UInt32 firstQuery, UInt32 queryCount, IMgBuffer dstBuffer, UInt64 dstOffset, UInt64 stride, MgQueryResultFlagBits flags)
{
var bQueryPool = (VkQueryPool)queryPool;
Debug.Assert(bQueryPool != null);
var bDstBuffer = (VkBuffer)dstBuffer;
Debug.Assert(bDstBuffer != null);
Interops.vkCmdCopyQueryPoolResults(this.Handle, bQueryPool.Handle, firstQuery, queryCount, bDstBuffer.Handle, dstOffset, stride, (Magnesium.Vulkan.VkQueryResultFlags)flags);
}
public void CopyBuffer(IMgBuffer srcBuffer, IMgBuffer dstBuffer, MgBufferCopy[] pRegions)
{
if (srcBuffer == null)
{
throw new ArgumentNullException(nameof(srcBuffer));
}
if (dstBuffer == null)
{
throw new ArgumentNullException(nameof(dstBuffer));
}
if (pRegions == null)
{
throw new ArgumentNullException(nameof(pRegions));
}
var bSrcBuffer = (AmtBuffer)srcBuffer;
var bDstBuffer = (AmtBuffer)dstBuffer;
var regions = new List <AmtBlitCopyBufferRegionRecord>();
for (var i = 0; i < pRegions.Length; ++i)
{
if (pRegions[i].SrcOffset > nuint.MaxValue)
{
throw new ArgumentOutOfRangeException(nameof(pRegions) + "[" + i + "].SrcOffset must be less than " + nuint.MaxValue);
}
if (pRegions[i].DstOffset > nuint.MaxValue)
{
throw new ArgumentOutOfRangeException(nameof(pRegions) + "[" + i + "].DstOffset must be less than " + nuint.MaxValue);
}
if (pRegions[i].Size > nuint.MaxValue)
{
throw new ArgumentOutOfRangeException(nameof(pRegions) + "[" + i + "].Size must be less than " + nuint.MaxValue);
}
regions.Add(new AmtBlitCopyBufferRegionRecord
{
Size = (nuint)pRegions[i].Size,
DestinationOffset = (nuint)pRegions[i].DstOffset,
SourceOffset = (nuint)pRegions[i].SrcOffset,
});
}
var item = new AmtBlitCopyBufferRecord
{
Src = bSrcBuffer.VertexBuffer,
Dst = bDstBuffer.VertexBuffer,
Regions = regions.ToArray(),
};
var nextIndex = mBag.CopyBuffers.Push(item);
mInstructions.Add(
new AmtEncodingInstruction
{
Category = AmtEncoderCategory.Blit,
Index = nextIndex,
Operation = CmdCopyBuffer,
}
);
}
