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();
}
}
void ReleaseUnmanagedResources()
{
if (mFramebuffers != null)
{
foreach (var fb in mFramebuffers)
{
fb.DestroyFramebuffer(mPartition.Device, null);
}
mFramebuffers = null;
}
if (mRenderpass != null)
{
mRenderpass.DestroyRenderPass(mPartition.Device, null);
mRenderpass = null;
}
if (mView != null)
{
mView.DestroyImageView(mPartition.Device, null);
mView = null;
}
if (mImage != null)
{
mImage.DestroyImage(mPartition.Device, null);
mImage = null;
}
if (mDeviceMemory != null)
{
mDeviceMemory.FreeMemory(mPartition.Device, null);
mDeviceMemory = null;
}
}
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 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 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);
}
public void SubmitPrePresentBarrier(IMgCommandBuffer prePresent, IMgImage image)
{
if (prePresent == null)
{
throw new InvalidOperationException();
}
MgCommandBufferBeginInfo cmdBufInfo = new MgCommandBufferBeginInfo
{
};
var vkRes = prePresent.BeginCommandBuffer(cmdBufInfo);
Debug.Assert(vkRes == Result.SUCCESS, vkRes + " != Result.SUCCESS");
const uint VK_QUEUE_FAMILY_IGNORED = ~0U;
var prePresentBarrier = new MgImageMemoryBarrier
{
Image = image,
SrcAccessMask = MgAccessFlagBits.COLOR_ATTACHMENT_WRITE_BIT,
DstAccessMask = 0,
OldLayout = MgImageLayout.COLOR_ATTACHMENT_OPTIMAL,
NewLayout = MgImageLayout.PRESENT_SRC_KHR,
SrcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
DstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
SubresourceRange = new MgImageSubresourceRange
{
AspectMask = MgImageAspectFlagBits.COLOR_BIT,
BaseArrayLayer = 0,
LayerCount = 1,
BaseMipLevel = 0,
LevelCount = 1,
},
};
const int VK_FLAGS_NONE = 0;
prePresent.CmdPipelineBarrier(
MgPipelineStageFlagBits.ALL_COMMANDS_BIT,
MgPipelineStageFlagBits.TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
null, // No memory barriers,
null, // No buffer barriers,
new[] { prePresentBarrier });
vkRes = prePresent.EndCommandBuffer();
Debug.Assert(vkRes == Result.SUCCESS, vkRes + " != Result.SUCCESS");
}
// 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);
}
// public void DestroyImage (MgImage image, IMgAllocationCallbacks allocator)
// {
// mImages [image.Key].Destroy ();
// }
public void GetImageSubresourceLayout(IMgImage image, MgImageSubresource pSubresource, out MgSubresourceLayout pLayout)
{
var internalImage = (IGLImage)image;
if (internalImage != null &&
pSubresource.ArrayLayer < internalImage.ArrayLayers.Length &&
pSubresource.MipLevel < internalImage.ArrayLayers[pSubresource.ArrayLayer].Levels.Length)
{
pLayout = internalImage.ArrayLayers [pSubresource.ArrayLayer].Levels [pSubresource.MipLevel].SubresourceLayout;
}
else
{
pLayout = new MgSubresourceLayout {
};
}
}
void ReleaseUnmanagedResources()
{
mFramebuffers.Clear();
if (mRenderpass != null)
{
mRenderpass.DestroyRenderPass(mGraphicsConfiguration.Partition.Device, null);
mRenderpass = null;
}
if (mDepthStencilImageView != null)
{
mDepthStencilImageView.DestroyImageView(mGraphicsConfiguration.Partition.Device, null);
mDepthStencilImageView = null;
}
if (mImage != null)
{
mImage.DestroyImage(mGraphicsConfiguration.Partition.Device, null);
mImage = null;
}
if (mDeviceMemory != null)
{
mDeviceMemory.FreeMemory(mGraphicsConfiguration.Partition.Device, null);
mDeviceMemory = null;
}
}
void CreateDepthStencil(IMgCommandBuffer setupCmdBuffer, MgGraphicsDeviceCreateInfo createInfo)
{
var image = new MgImageCreateInfo {
ImageType = MgImageType.TYPE_2D,
Format = createInfo.DepthStencil,
Extent = new MgExtent3D {
Width = createInfo.Width,
Height = createInfo.Height,
Depth = 1
},
MipLevels = 1,
ArrayLayers = 1,
Samples = createInfo.Samples,
Tiling = MgImageTiling.OPTIMAL,
// TODO : multisampled uses MgImageUsageFlagBits.TRANSIENT_ATTACHMENT_BIT | MgImageUsageFlagBits.DEPTH_STENCIL_ATTACHMENT_BIT;
Usage = MgImageUsageFlagBits.DEPTH_STENCIL_ATTACHMENT_BIT | MgImageUsageFlagBits.TRANSFER_SRC_BIT,
Flags = 0,
};
var mem_alloc = new MgMemoryAllocateInfo {
AllocationSize = 0,
MemoryTypeIndex = 0,
};
MgMemoryRequirements memReqs;
Debug.Assert(mGraphicsConfiguration.Partition != null);
Result err;
{
IMgImage dsImage;
err = mGraphicsConfiguration.Partition.Device.CreateImage(image, null, out dsImage);
Debug.Assert(err == Result.SUCCESS, err + " != Result.SUCCESS");
mImage = dsImage;
}
mGraphicsConfiguration.Partition.Device.GetImageMemoryRequirements(mImage, out memReqs);
mem_alloc.AllocationSize = memReqs.Size;
uint memTypeIndex;
bool memoryTypeFound = mGraphicsConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits, MgMemoryPropertyFlagBits.DEVICE_LOCAL_BIT, out memTypeIndex);
Debug.Assert(memoryTypeFound);
mem_alloc.MemoryTypeIndex = memTypeIndex;
{
IMgDeviceMemory dsDeviceMemory;
err = mGraphicsConfiguration.Partition.Device.AllocateMemory(mem_alloc, null, out dsDeviceMemory);
Debug.Assert(err == Result.SUCCESS, err + " != Result.SUCCESS");
mDeviceMemory = dsDeviceMemory;
}
err = mImage.BindImageMemory(mGraphicsConfiguration.Partition.Device, mDeviceMemory, 0);
Debug.Assert(err == Result.SUCCESS, err + " != Result.SUCCESS");
mImageTools.SetImageLayout(setupCmdBuffer, mImage, MgImageAspectFlagBits.DEPTH_BIT | MgImageAspectFlagBits.STENCIL_BIT, MgImageLayout.UNDEFINED, MgImageLayout.DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
var depthStencilView = new MgImageViewCreateInfo {
Image = mImage,
ViewType = MgImageViewType.TYPE_2D,
Format = createInfo.DepthStencil,
Flags = 0,
SubresourceRange = new MgImageSubresourceRange {
AspectMask = MgImageAspectFlagBits.DEPTH_BIT | MgImageAspectFlagBits.STENCIL_BIT,
BaseMipLevel = 0,
LevelCount = 1,
BaseArrayLayer = 0,
LayerCount = 1,
},
};
{
IMgImageView dsView;
err = mGraphicsConfiguration.Partition.Device.CreateImageView(depthStencilView, null, out dsView);
Debug.Assert(err == Result.SUCCESS, err + " != Result.SUCCESS");
mDepthStencilImageView = dsView;
}
}
public void SubmitPrePresentBarrier(IMgCommandBuffer prePresent, IMgImage image)
{
}
public void GetImageSubresourceLayout(IMgImage image, MgImageSubresource pSubresource, out MgSubresourceLayout pLayout)
{
throw new NotImplementedException();
}
public void GetImageSparseMemoryRequirements(IMgImage image, out MgSparseImageMemoryRequirements[] sparseMemoryRequirements)
{
throw new NotImplementedException();
}
public void GetImageMemoryRequirements(IMgImage image, out MgMemoryRequirements memoryRequirements)
{
throw new NotImplementedException();
}
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,
});
}
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 CmdCopyImage(IMgImage srcImage, MgImageLayout srcImageLayout, IMgImage dstImage, MgImageLayout dstImageLayout, MgImageCopy[] pRegions)
{
throw new NotImplementedException();
}
// 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 });
}
// 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 });
}
public Result CreateImage(MgImageCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgImage pImage)
{
if (pCreateInfo == null)
{
throw new ArgumentNullException("pCreateInfo");
}
// ARB_texture_storage
int[] textureId = new int[1];
int width = (int)pCreateInfo.Extent.Width;
int height = (int)pCreateInfo.Extent.Height;
int depth = (int)pCreateInfo.Extent.Depth;
int levels = (int)pCreateInfo.MipLevels;
int arrayLayers = (int)pCreateInfo.ArrayLayers;
//var internalFormat = GetInternalFormat(pCreateInfo.Format);
var imageType = pCreateInfo.ImageType;
switch (pCreateInfo.ImageType)
{
case MgImageType.TYPE_1D:
// GL.CreateTextures (TextureTarget.Texture1D, 1, textureId);
// GL.Ext.TextureStorage1D (textureId [0], (ExtDirectStateAccess)All.Texture1D, levels, internalFormat, width);
textureId[0] = mEntrypoint.Image.CreateTextureStorage1D(levels, pCreateInfo.Format, width);
break;
case MgImageType.TYPE_2D:
// GL.CreateTextures (TextureTarget.Texture2D, 1, textureId);
// GL.Ext.TextureStorage2D (textureId[0], (ExtDirectStateAccess)All.Texture2D, levels, internalFormat, width, height);
textureId[0] = mEntrypoint.Image.CreateTextureStorage2D(levels, pCreateInfo.Format, width, height);
break;
case MgImageType.TYPE_3D:
// GL.CreateTextures (TextureTarget.Texture3D, 1, textureId);
// GL.Ext.TextureStorage3D (textureId [0], (ExtDirectStateAccess)All.Texture3D, levels, internalFormat, width, height, depth);
textureId [0] = mEntrypoint.Image.CreateTextureStorage3D(levels, pCreateInfo.Format, width, height, depth);
break;
default:
throw new NotSupportedException();
}
pImage = new GLImage(mEntrypoint.Image, textureId[0], imageType, pCreateInfo.Format, width, height, depth, levels, arrayLayers);
return(Result.SUCCESS);
}
public void GetImageMemoryRequirements(IMgImage image, out MgMemoryRequirements memoryRequirements)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
var texture = (IGLImage)image;
uint imageSize = 0;
uint width = (uint)texture.Width;
uint height = (uint)texture.Height;
uint size = Math.Max(width, height);
for (int i = 0; i < texture.Levels; ++i)
{
Debug.Assert(size >= 1);
var format = texture.Format;
switch (format)
{
// FIXME :
// //case SurfaceFormat.RgbPvrtc2Bpp:
// case SurfaceFormat.RgbaPvrtc2Bpp:
// imageSize = (Math.Max(this.width, 16) * Math.Max(this.height, 8) * 2 + 7) / 8;
// break;
// case SurfaceFormat.RgbPvrtc4Bpp:
// case SurfaceFormat.RgbaPvrtc4Bpp:
// imageSize = (Math.Max(this.width, 8) * Math.Max(this.height, 8) * 4 + 7) / 8;
// break;
case MgFormat.BC1_RGB_UNORM_BLOCK:
//case SurfaceFormat.Dxt1:
case MgFormat.BC1_RGBA_UNORM_BLOCK:
//case SurfaceFormat.Dxt1a:
case MgFormat.BC1_RGB_SRGB_BLOCK:
//case SurfaceFormat.Dxt1SRgb:
case MgFormat.BC2_UNORM_BLOCK:
//case SurfaceFormat.Dxt3:
case MgFormat.BC2_SRGB_BLOCK:
//case SurfaceFormat.Dxt3SRgb:
case MgFormat.BC3_UNORM_BLOCK:
//case SurfaceFormat.Dxt5:
case MgFormat.BC3_SRGB_BLOCK:
//case SurfaceFormat.Dxt5SRgb:
//case SurfaceFormat.RgbEtc1:
//case SurfaceFormat.RgbaAtcExplicitAlpha:
//case SurfaceFormat.RgbaAtcInterpolatedAlpha:
imageSize += ((width + 3) / 4) * ((height + 3) / 4) * GetSize(format);
break;
default:
imageSize += GetSize(format) * width * height;
break;
//return Result.ERROR_FEATURE_NOT_PRESENT;
}
if (width > 1)
{
width = width / 2;
}
if (height > 1)
{
height = height / 2;
}
}
memoryRequirements = new MgMemoryRequirements {
// HOST ONLY OR DEVICE
MemoryTypeBits = GLMemoryBufferType.IMAGE.GetMask(),
Size = imageSize,
};
}
// 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 CopyImageToBuffer(IMgImage srcImage, MgImageLayout srcImageLayout, IMgBuffer dstBuffer, MgBufferImageCopy[] pRegions)
{
throw new NotImplementedException();
}
public Result CreateImage(MgImageCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgImage pImage)
{
Debug.Assert(pCreateInfo != null);
var depth = (nuint)pCreateInfo.Extent.Depth;
var height = (nuint)pCreateInfo.Extent.Height;
var width = (nuint)pCreateInfo.Extent.Width;
var arrayLayers = (nuint)pCreateInfo.ArrayLayers;
var mipLevels = (nuint)pCreateInfo.MipLevels;
//TODO : Figure this out
var storageMode = MTLStorageMode.Shared;
var resourceOptions = MTLResourceOptions.CpuCacheModeDefault;
var cpuCacheMode = MTLCpuCacheMode.DefaultCache;
var descriptor = new MTLTextureDescriptor
{
ArrayLength = arrayLayers,
PixelFormat = AmtFormatExtensions.GetPixelFormat(pCreateInfo.Format),
SampleCount = AmtSampleCountFlagBitExtensions.TranslateSampleCount(pCreateInfo.Samples),
TextureType = TranslateTextureType(pCreateInfo.ImageType),
StorageMode = storageMode,
Width = width,
Height = height,
Depth = depth,
MipmapLevelCount = mipLevels,
Usage = TranslateUsage(pCreateInfo.Usage),
ResourceOptions = resourceOptions,
CpuCacheMode = cpuCacheMode,
};
var texture = mDevice.CreateTexture(descriptor);
pImage = new AmtImage(texture);
return(Result.SUCCESS);
}
public void CmdBlitImage(IMgImage srcImage, MgImageLayout srcImageLayout, IMgImage dstImage, MgImageLayout dstImageLayout, MgImageBlit[] pRegions, MgFilter filter)
{
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 CreateImage(MgImageCreateInfo pCreateInfo, IMgAllocationCallbacks allocator, out IMgImage pImage)
{
throw new NotImplementedException();
}
public void CmdClearColorImage(IMgImage image, MgImageLayout imageLayout, MgClearColorValue pColor, MgImageSubresourceRange[] pRanges)
{
throw new NotImplementedException();
}
