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 void CmdResolveImage(IMgImage srcImage, MgImageLayout srcImageLayout, IMgImage dstImage, MgImageLayout dstImageLayout, MgImageResolve[] pRegions)
{
var bSrcImage = (VkImage)srcImage;
Debug.Assert(bSrcImage != null);
var bDstImage = (VkImage)dstImage;
Debug.Assert(bDstImage != null);
var handle = GCHandle.Alloc(pRegions, GCHandleType.Pinned);
try
{
unsafe
{
var regionCount = (uint)pRegions.Length;
var regionAddress = handle.AddrOfPinnedObject();
var pinnedArray = (MgImageResolve *)regionAddress.ToPointer();
Interops.vkCmdResolveImage(this.Handle, bSrcImage.Handle, srcImageLayout, bDstImage.Handle, dstImageLayout, regionCount, pinnedArray);
}
}
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 CmdClearDepthStencilImage(IMgImage image, MgImageLayout imageLayout, MgClearDepthStencilValue pDepthStencil, MgImageSubresourceRange[] pRanges)
{
var bImage = (VkImage)image;
Debug.Assert(bImage != null);
Interops.vkCmdClearDepthStencilImage(this.Handle, bImage.Handle, imageLayout, pDepthStencil, (uint)pRanges.Length, pRanges);
}
public void CmdBlitImage(IMgImage srcImage, MgImageLayout srcImageLayout, IMgImage dstImage, MgImageLayout dstImageLayout, MgImageBlit[] pRegions, MgFilter filter)
{
var bSrcImage = (VkImage)srcImage;
Debug.Assert(bSrcImage != null);
var bDstImage = (VkImage)dstImage;
Debug.Assert(bDstImage != null);
Interops.vkCmdBlitImage(this.Handle, bSrcImage.Handle, srcImageLayout, bDstImage.Handle, dstImageLayout, (uint)pRegions.Length, pRegions, (VkFilter)filter);
}
// Fixed sub resource on first mip level and layer
public void SetImageLayout(
IMgCommandBuffer cmdbuffer,
IMgImage image,
MgImageAspectFlagBits aspectMask,
MgImageLayout oldImageLayout,
MgImageLayout newImageLayout)
{
var subresourceRange = new MgImageSubresourceRange {
AspectMask = aspectMask,
BaseMipLevel = 0,
LevelCount = 1,
LayerCount = 1,
};
PushImageMemoryBarrier(cmdbuffer, image, aspectMask, oldImageLayout, newImageLayout, subresourceRange);
}
// Create an image memory barrier for changing the layout of
// an image and put it into an active command buffer
void setImageLayout(IMgCommandBuffer cmdBuffer, IMgImage image, MgImageAspectFlagBits aspectMask, MgImageLayout oldImageLayout, MgImageLayout newImageLayout, MgImageSubresourceRange subresourceRange)
{
// Create an image barrier object
var imageMemoryBarrier = new MgImageMemoryBarrier
{
OldLayout = oldImageLayout,
NewLayout = newImageLayout,
Image = image,
SubresourceRange = subresourceRange,
};
// Only sets masks for layouts used in this example
// For a more complete version that can be used with other layouts see IMgTools::setImageLayout
// Source layouts (old)
switch (oldImageLayout)
{
case MgImageLayout.UNDEFINED:
// Only valid as initial layout, memory contents are not preserved
// Can be accessed directly, no source dependency required
imageMemoryBarrier.SrcAccessMask = 0;
break;
case MgImageLayout.PREINITIALIZED:
// Only valid as initial layout for linear images, preserves memory contents
// Make sure host writes to the image have been finished
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.HOST_WRITE_BIT;
break;
case MgImageLayout.TRANSFER_DST_OPTIMAL:
// Old layout is transfer destination
// Make sure any writes to the image have been finished
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.TRANSFER_WRITE_BIT;
break;
}
// Target layouts (new)
switch (newImageLayout)
{
case MgImageLayout.TRANSFER_SRC_OPTIMAL:
// Transfer source (copy, blit)
// Make sure any reads from the image have been finished
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.TRANSFER_READ_BIT;
break;
case MgImageLayout.TRANSFER_DST_OPTIMAL:
// Transfer destination (copy, blit)
// Make sure any writes to the image have been finished
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.TRANSFER_WRITE_BIT;
break;
case MgImageLayout.SHADER_READ_ONLY_OPTIMAL:
// Shader read (sampler, input attachment)
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.SHADER_READ_BIT;
break;
}
// Put barrier on top of pipeline
var srcStageFlags = MgPipelineStageFlagBits.TOP_OF_PIPE_BIT;
var destStageFlags = MgPipelineStageFlagBits.TOP_OF_PIPE_BIT;
// Put barrier inside setup command buffer
cmdBuffer.CmdPipelineBarrier(
srcStageFlags,
destStageFlags,
0,
null,
null,
new[] { imageMemoryBarrier });
}
public void CmdCopyBufferToImage(IMgBuffer srcBuffer, IMgImage dstImage, MgImageLayout dstImageLayout, MgBufferImageCopy[] pRegions)
{
mCommandEncoder.Blit.CopyBufferToImage(srcBuffer, dstImage, dstImageLayout, pRegions);
}
internal extern static unsafe void vkCmdClearDepthStencilImage(IntPtr commandBuffer, UInt64 image, MgImageLayout imageLayout, [In] MgClearDepthStencilValue pDepthStencil, UInt32 rangeCount, [In] Magnesium.MgImageSubresourceRange[] pRanges);
internal extern static unsafe void vkCmdCopyImageToBuffer(IntPtr commandBuffer, UInt64 srcImage, MgImageLayout srcImageLayout, UInt64 dstBuffer, UInt32 regionCount, MgBufferImageCopy *pRegions);
public void CmdResolveImage(IMgImage srcImage, MgImageLayout srcImageLayout, IMgImage dstImage, MgImageLayout dstImageLayout, MgImageResolve[] pRegions)
{
throw new NotImplementedException();
}
public void CopyImageToBuffer(IMgImage srcImage, MgImageLayout srcImageLayout, IMgBuffer dstBuffer, MgBufferImageCopy[] pRegions)
{
throw new NotImplementedException();
}
public void CopyBufferToImage(IMgBuffer srcBuffer, IMgImage dstImage, MgImageLayout dstImageLayout, MgBufferImageCopy[] pRegions)
{
throw new NotImplementedException();
}
public void CmdClearDepthStencilImage(IMgImage image, MgImageLayout imageLayout, MgClearDepthStencilValue pDepthStencil, MgImageSubresourceRange[] pRanges)
{
throw new NotImplementedException();
}
public void CmdClearColorImage(IMgImage image, MgImageLayout imageLayout, MgClearColorValue pColor, MgImageSubresourceRange[] pRanges)
{
throw new NotImplementedException();
}
public void CmdBlitImage(IMgImage srcImage, MgImageLayout srcImageLayout, IMgImage dstImage, MgImageLayout dstImageLayout, MgImageBlit[] pRegions, MgFilter filter)
{
throw new NotImplementedException();
}
internal extern static void vkCmdBlitImage(IntPtr commandBuffer, UInt64 srcImage, MgImageLayout srcImageLayout, UInt64 dstImage, MgImageLayout dstImageLayout, UInt32 regionCount, [In] MgImageBlit[] pRegions, VkFilter filter);
public void CmdCopyImage(IMgImage srcImage, MgImageLayout srcImageLayout, IMgImage dstImage, MgImageLayout dstImageLayout, MgImageCopy[] pRegions)
{
throw new NotImplementedException();
}
public void CmdCopyImageToBuffer(IMgImage srcImage, MgImageLayout srcImageLayout, IMgBuffer dstBuffer, MgBufferImageCopy[] pRegions)
{
mCommandEncoder.Blit.CopyImageToBuffer(srcImage, srcImageLayout, dstBuffer, pRegions);
}
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 void CmdCopyImage(IMgImage srcImage, MgImageLayout srcImageLayout,
IMgImage dstImage, MgImageLayout dstImageLayout, MgImageCopy[] pRegions)
{
if (srcImage == null)
{
throw new ArgumentNullException(nameof(srcImage));
}
if (dstImage == null)
{
throw new ArgumentNullException(nameof(dstImage));
}
if (pRegions == null)
{
throw new ArgumentNullException(nameof(pRegions));
}
var bSrcImage = (AmtImage)srcImage;
var bDstImage = (AmtImage)dstImage;
var regions = new List <AmtBlitCopyImageRegionRecord>();
for (var i = 0; i < pRegions.Length; ++i)
{
var currentRegion = pRegions[i];
var extent = currentRegion.Extent;
if (extent.Width > nint.MaxValue)
{
throw new ArgumentOutOfRangeException(
"pRegions[" + i + "].Extent.Width must be <=" + nint.MaxValue);
}
if (extent.Height > nint.MaxValue)
{
throw new ArgumentOutOfRangeException(
"pRegions[" + i + "].Extent.Height must be <= " + nint.MaxValue);
}
if (extent.Depth > nint.MaxValue)
{
throw new ArgumentOutOfRangeException(
"pRegions[" + i + "].Extent.Depth must be <= " + nint.MaxValue);
}
regions.Add(new AmtBlitCopyImageRegionRecord
{
SourceSlice = currentRegion.SrcSubresource.BaseArrayLayer,
SourceMipLevel = currentRegion.SrcSubresource.MipLevel,
SourceOrigin = new MTLOrigin
{
X = currentRegion.SrcOffset.X,
Y = currentRegion.SrcOffset.Y,
Z = currentRegion.SrcOffset.Z
},
SourceLayerCount = currentRegion.SrcSubresource.LayerCount,
SourceSize = new MTLSize
{
Width = (nint)currentRegion.Extent.Width,
Height = (nint)currentRegion.Extent.Height,
Depth = (nint)currentRegion.Extent.Depth,
},
DestinationSlice = currentRegion.DstSubresource.BaseArrayLayer,
DestinationMipLevel = currentRegion.DstSubresource.MipLevel,
DestinationLayerCount = currentRegion.DstSubresource.LayerCount,
DestinationOrigin = new MTLOrigin
{
X = currentRegion.DstOffset.X,
Y = currentRegion.DstOffset.Y,
Z = currentRegion.DstOffset.Z
},
});
}
var item = new AmtBlitCopyImageRecord
{
Source = bSrcImage.OriginalTexture,
Destination = bDstImage.OriginalTexture,
Regions = regions.ToArray(),
};
var nextIndex = mBag.CopyImages.Push(item);
mInstructions.Add(new AmtEncodingInstruction
{
Category = AmtEncoderCategory.Blit,
Index = nextIndex,
Operation = CmdCopyImage,
});
}
internal extern static unsafe void vkCmdCopyBufferToImage(IntPtr commandBuffer, UInt64 srcBuffer, UInt64 dstImage, MgImageLayout dstImageLayout, UInt32 regionCount, MgBufferImageCopy *pRegions);
// Create an image memory barrier for changing the layout of
// an image and put it into an active command buffer
// See chapter 11.4 "Image Layout" for details
private void PushImageMemoryBarrier(
IMgCommandBuffer cmdbuffer,
IMgImage image,
MgImageAspectFlagBits aspectMask,
MgImageLayout oldImageLayout,
MgImageLayout newImageLayout,
MgImageSubresourceRange subresourceRange)
{
const uint VK_QUEUE_FAMILY_IGNORED = ~0U; // 0xffffffff;
// Create an image barrier object
MgImageMemoryBarrier imageMemoryBarrier = new MgImageMemoryBarrier {
OldLayout = oldImageLayout,
NewLayout = newImageLayout,
Image = image,
SubresourceRange = subresourceRange,
// Some default values
SrcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
DstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
};
// Source layouts (old)
// Undefined layout
// Only allowed as initial layout!
// Make sure any writes to the image have been finished
if (oldImageLayout == MgImageLayout.PREINITIALIZED)
{
imageMemoryBarrier.SrcAccessMask = (MgAccessFlagBits.HOST_WRITE_BIT | MgAccessFlagBits.TRANSFER_WRITE_BIT);
}
// Old layout is color attachment
// Make sure any writes to the color buffer have been finished
if (oldImageLayout == MgImageLayout.COLOR_ATTACHMENT_OPTIMAL)
{
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.COLOR_ATTACHMENT_WRITE_BIT;
}
// Old layout is depth/stencil attachment
// Make sure any writes to the depth/stencil buffer have been finished
if (oldImageLayout == MgImageLayout.DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
{
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
}
// Old layout is transfer source
// Make sure any reads from the image have been finished
if (oldImageLayout == MgImageLayout.TRANSFER_SRC_OPTIMAL)
{
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.TRANSFER_READ_BIT;
}
// Old layout is shader read (sampler, input attachment)
// Make sure any shader reads from the image have been finished
if (oldImageLayout == MgImageLayout.SHADER_READ_ONLY_OPTIMAL)
{
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.SHADER_READ_BIT;
}
// Target layouts (new)
// New layout is transfer destination (copy, blit)
// Make sure any copyies to the image have been finished
if (newImageLayout == MgImageLayout.TRANSFER_DST_OPTIMAL)
{
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.TRANSFER_WRITE_BIT;
}
// New layout is transfer source (copy, blit)
// Make sure any reads from and writes to the image have been finished
if (newImageLayout == MgImageLayout.TRANSFER_SRC_OPTIMAL)
{
imageMemoryBarrier.SrcAccessMask = imageMemoryBarrier.SrcAccessMask | MgAccessFlagBits.TRANSFER_READ_BIT;
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.TRANSFER_READ_BIT;
}
// New layout is color attachment
// Make sure any writes to the color buffer have been finished
if (newImageLayout == MgImageLayout.COLOR_ATTACHMENT_OPTIMAL)
{
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.COLOR_ATTACHMENT_WRITE_BIT;
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.TRANSFER_READ_BIT;
}
// New layout is depth attachment
// Make sure any writes to depth/stencil buffer have been finished
if (newImageLayout == MgImageLayout.DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
{
imageMemoryBarrier.DstAccessMask = imageMemoryBarrier.DstAccessMask | MgAccessFlagBits.DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
}
// New layout is shader read (sampler, input attachment)
// Make sure any writes to the image have been finished
if (newImageLayout == MgImageLayout.SHADER_READ_ONLY_OPTIMAL)
{
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.HOST_WRITE_BIT | MgAccessFlagBits.TRANSFER_WRITE_BIT;
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.SHADER_READ_BIT;
}
// Put barrier on top
MgPipelineStageFlagBits srcStageFlags = MgPipelineStageFlagBits.TOP_OF_PIPE_BIT;
MgPipelineStageFlagBits destStageFlags = MgPipelineStageFlagBits.TOP_OF_PIPE_BIT;
// Put barrier inside setup command buffer
cmdbuffer.CmdPipelineBarrier(
srcStageFlags,
destStageFlags,
0,
null,
null,
new [] { imageMemoryBarrier });
}
internal extern static void vkCmdClearColorImage(IntPtr commandBuffer, UInt64 image, MgImageLayout imageLayout, [In] MgClearColorValue pColor, UInt32 rangeCount, [In] Magnesium.MgImageSubresourceRange[] pRanges);
// Create an image memory barrier for changing the layout of
// an image and put it into an active command buffer
public void SetImageLayout(
IMgCommandBuffer cmdBuffer,
IMgImage image,
MgImageAspectFlagBits aspectMask,
MgImageLayout oldImageLayout,
MgImageLayout newImageLayout,
uint mipLevel,
uint mipLevelCount)
{
// Create an image barrier object
var imageMemoryBarrier = new MgImageMemoryBarrier()
{
OldLayout = oldImageLayout,
NewLayout = newImageLayout,
Image = image,
SubresourceRange = new MgImageSubresourceRange {
AspectMask = aspectMask,
BaseMipLevel = mipLevel,
LevelCount = mipLevelCount,
LayerCount = 1,
},
};
// Only sets masks for layouts used in this example
// For a more complete version that can be used with
// other layouts see vkTools::setImageLayout
// Source layouts (new)
if (oldImageLayout == MgImageLayout.PREINITIALIZED)
{
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.HOST_WRITE_BIT | MgAccessFlagBits.TRANSFER_WRITE_BIT;
}
// Target layouts (new)
// New layout is transfer destination (copy, blit)
// Make sure any reads from and writes to the image have been finished
if (newImageLayout == MgImageLayout.TRANSFER_DST_OPTIMAL)
{
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.TRANSFER_READ_BIT | MgAccessFlagBits.HOST_WRITE_BIT | MgAccessFlagBits.TRANSFER_WRITE_BIT;
}
// New layout is shader read (sampler, input attachment)
// Make sure any writes to the image have been finished
if (newImageLayout == MgImageLayout.SHADER_READ_ONLY_OPTIMAL)
{
imageMemoryBarrier.SrcAccessMask = MgAccessFlagBits.HOST_WRITE_BIT | MgAccessFlagBits.TRANSFER_WRITE_BIT;
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.SHADER_READ_BIT;
}
// New layout is transfer source (copy, blit)
// Make sure any reads from and writes to the image have been finished
if (newImageLayout == MgImageLayout.TRANSFER_SRC_OPTIMAL)
{
imageMemoryBarrier.DstAccessMask = MgAccessFlagBits.TRANSFER_READ_BIT | MgAccessFlagBits.HOST_WRITE_BIT | MgAccessFlagBits.TRANSFER_WRITE_BIT;
}
// Put barrier on top
MgPipelineStageFlagBits srcStageFlags = MgPipelineStageFlagBits.TOP_OF_PIPE_BIT;
MgPipelineStageFlagBits destStageFlags = MgPipelineStageFlagBits.TOP_OF_PIPE_BIT;
const int VK_FLAGS_NONE = 0;
// Put barrier inside setup command buffer
cmdBuffer.CmdPipelineBarrier(
srcStageFlags,
destStageFlags,
VK_FLAGS_NONE,
null,
null,
new [] { imageMemoryBarrier });
}
internal extern static unsafe void vkCmdResolveImage(IntPtr commandBuffer, UInt64 srcImage, MgImageLayout srcImageLayout, UInt64 dstImage, MgImageLayout dstImageLayout, UInt32 regionCount, MgImageResolve *pRegions);
public void CmdCopyImage(IMgImage srcImage, MgImageLayout srcImageLayout, IMgImage dstImage, MgImageLayout dstImageLayout, MgImageCopy[] pRegions)
{
mCommandEncoder.Blit.CmdCopyImage(srcImage, srcImageLayout, dstImage, dstImageLayout, pRegions);
}
