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