/// <summary> /// Create a new Image. /// </summary> /// <remarks>Initial layout will be automatically set to Undefined if tiling is optimal and Preinitialized if tiling is linear.</remarks> /// <param name="device">The logical device that create the image.</param> /// <param name="format">format and type of the texel blocks that will be contained in the image</param> /// <param name="usage">bitmask describing the intended usage of the image.</param> /// <param name="_memoryPropertyFlags">Memory property flags.</param> /// <param name="width">number of data in the X dimension of the image.</param> /// <param name="height">number of data in the Y dimension of the image.</param> /// <param name="type">value specifying the basic dimensionality of the image. Layers in array textures do not count as a dimension for the purposes of the image type.</param> /// <param name="samples">number of sample per texel.</param> /// <param name="tiling">tiling arrangement of the texel blocks in memory.</param> /// <param name="mipsLevels">describes the number of levels of detail available for minified sampling of the image.</param> /// <param name="layers">number of layers in the image.</param> /// <param name="depth">number of data in the Z dimension of the image</param> /// <param name="createFlags">bitmask describing additional parameters of the image.</param> /// <param name="sharingMode">value specifying the sharing mode of the image when it will be accessed by multiple queue families.</param> /// <param name="queuesFamillies">list of queue families that will access this image (ignored if sharingMode is not CONCURRENT).</param> public Image(Device device, VkFormat format, VkImageUsageFlags usage, VkMemoryPropertyFlags _memoryPropertyFlags, uint width, uint height, VkImageType type = VkImageType.Image2D, VkSampleCountFlags samples = VkSampleCountFlags.SampleCount1, VkImageTiling tiling = VkImageTiling.Optimal, uint mipsLevels = 1, uint layers = 1, uint depth = 1, VkImageCreateFlags createFlags = 0, VkSharingMode sharingMode = VkSharingMode.Exclusive, params uint[] queuesFamillies) : base(device, _memoryPropertyFlags) { info.imageType = type; info.format = format; info.extent.width = width; info.extent.height = height; info.extent.depth = depth; info.mipLevels = mipsLevels; info.arrayLayers = layers; info.samples = samples; info.tiling = tiling; info.usage = usage; info.initialLayout = (tiling == VkImageTiling.Optimal) ? VkImageLayout.Undefined : VkImageLayout.Preinitialized; info.sharingMode = sharingMode; info.flags = createFlags; this.queueFalillies = queuesFamillies; lastKnownLayout = info.initialLayout; Activate(); }
internal void TransitionImageLayout( VkCommandBuffer cb, uint baseMipLevel, uint levelCount, uint baseArrayLayer, uint layerCount, VkImageLayout newLayout) { if (_stagingBuffer != Vulkan.VkBuffer.Null) { return; } VkImageLayout oldLayout = _imageLayouts[CalculateSubresource(baseMipLevel, baseArrayLayer)]; #if DEBUG for (uint level = 0; level < levelCount; level++) { for (uint layer = 0; layer < layerCount; layer++) { if (_imageLayouts[CalculateSubresource(baseMipLevel + level, baseArrayLayer + layer)] != oldLayout) { throw new VeldridException("Unexpected image layout."); } } } #endif if (oldLayout != newLayout) { VkImageAspectFlags aspectMask; if ((Usage & TextureUsage.DepthStencil) != 0) { aspectMask = FormatHelpers.IsStencilFormat(Format) ? aspectMask = VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil : aspectMask = VkImageAspectFlags.Depth; } else { aspectMask = VkImageAspectFlags.Color; } VulkanUtil.TransitionImageLayout( cb, OptimalDeviceImage, baseMipLevel, levelCount, baseArrayLayer, layerCount, aspectMask, _imageLayouts[CalculateSubresource(baseMipLevel, baseArrayLayer)], newLayout); for (uint level = 0; level < levelCount; level++) { for (uint layer = 0; layer < layerCount; layer++) { _imageLayouts[CalculateSubresource(baseMipLevel + level, baseArrayLayer + layer)] = newLayout; } } } }
public void SetLayout(CommandBuffer cmdbuffer, VkImageAspectFlags aspectMask, VkImageLayout oldImageLayout, VkImageLayout newImageLayout) { SetLayout(cmdbuffer, aspectMask, oldImageLayout, newImageLayout, oldImageLayout.GetDefaultStage(), newImageLayout.GetDefaultStage()); }
public unsafe void cmdCopyImageToBuffer(VkImage SrcImage, VkImageLayout ImageLayout, VkBuffer DstBuffer, VkBufferImageCopy[] Regions) { fixed(VkBufferImageCopy *pRegions = &Regions[0]) { _Parent.Device.vkCmdCopyImageToBuffer(_Handle, SrcImage._Handle, ImageLayout, DstBuffer._Handle, (uint)Regions.Length, new IntPtr(pRegions)); } }
private void setImageMemoryBarrier(VkCommandBuffer command, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImage image, VkImageAspectFlags aspectFlags) { var imageMemoryBarrier = new VkImageMemoryBarrier() { srcAccessMask = srcAccessMask, dstAccessMask = dstAccessMask, oldLayout = oldLayout, newLayout = newLayout, srcQueueFamilyIndex = ~0u, dstQueueFamilyIndex = ~0u, subresourceRange = new VkImageSubresourceRange { aspectMask = aspectFlags, baseMipLevel = 0, levelCount = 1, baseArrayLayer = 0, layerCount = 1, }, image = image }; VulkanAPI.vkCmdPipelineBarrier( command, VkPipelineStageFlags.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VkPipelineStageFlags.VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, null, // MemoryBarriers null, // BufferMemoryBarriers new VkImageMemoryBarrier[] { imageMemoryBarrier } ); }
private (VkAttachmentDescription, VkAttachmentReference) CreateAttachment( VkFormat format, VkSampleCountFlags samples, uint index, VkAttachmentLoadOp loadOp, VkAttachmentStoreOp storeOp, VkAttachmentStoreOp stencilStoreOp, VkImageLayout initialLayout, VkImageLayout finalLayout) { return(new VkAttachmentDescription() { format = format, samples = samples, loadOp = loadOp, storeOp = storeOp, stencilLoadOp = VkAttachmentLoadOp.Load, stencilStoreOp = stencilStoreOp, initialLayout = initialLayout, finalLayout = finalLayout }, new VkAttachmentReference() { attachment = index, layout = finalLayout }); }
private KeyValuePair <VkAccessFlags, VkPipelineStageFlags> GetImageTransferFlags( VkImageLayout layout ) { switch (layout) { case VkImageLayout.TransferDstOptimal: return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>( VkAccessFlags.TransferWrite, VkPipelineStageFlags.Transfer )); case VkImageLayout.TransferSrcOptimal: return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>( VkAccessFlags.TransferRead, VkPipelineStageFlags.Transfer )); case VkImageLayout.Undefined: return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>( VkAccessFlags.None, VkPipelineStageFlags.TopOfPipe )); case VkImageLayout.ColorAttachmentOptimal: return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>( VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite, VkPipelineStageFlags.ColorAttachmentOutput )); case VkImageLayout.PresentSrcKHR: return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>( VkAccessFlags.ColorAttachmentRead, VkPipelineStageFlags.ColorAttachmentOutput )); case VkImageLayout.DepthStencilAttachmentOptimal: return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>( VkAccessFlags.DepthStencilAttachmentRead | VkAccessFlags.DepthStencilAttachmentWrite, VkPipelineStageFlags.EarlyFragmentTests )); case VkImageLayout.General: return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>( VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite, VkPipelineStageFlags.ColorAttachmentOutput )); case VkImageLayout.ShaderReadOnlyOptimal: return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>( VkAccessFlags.ShaderRead, VkPipelineStageFlags.AllGraphics )); } return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>( VkAccessFlags.None, VkPipelineStageFlags.None )); }
public void SetLayout( CommandBuffer cmdbuffer, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldImageLayout, VkImageLayout newImageLayout, VkImageSubresourceRange subresourceRange, VkPipelineStageFlags srcStageMask = VkPipelineStageFlags.AllCommands, VkPipelineStageFlags dstStageMask = VkPipelineStageFlags.AllCommands, uint srcQueueFamilyIndex = Vk.QueueFamilyIgnored, uint dstQueueFamilyIndex = Vk.QueueFamilyIgnored) { VkImageMemoryBarrier imageMemoryBarrier = VkImageMemoryBarrier.New(); imageMemoryBarrier.srcQueueFamilyIndex = srcQueueFamilyIndex; imageMemoryBarrier.dstQueueFamilyIndex = dstQueueFamilyIndex; imageMemoryBarrier.oldLayout = oldImageLayout; imageMemoryBarrier.newLayout = newImageLayout; imageMemoryBarrier.image = handle; imageMemoryBarrier.subresourceRange = subresourceRange; imageMemoryBarrier.srcAccessMask = srcAccessMask; imageMemoryBarrier.dstAccessMask = dstAccessMask; Vk.vkCmdPipelineBarrier( cmdbuffer.Handle, srcStageMask, dstStageMask, 0, 0, IntPtr.Zero, 0, IntPtr.Zero, 1, ref imageMemoryBarrier); }
public unsafe VkImageMemoryBarrier( VkImage image, VkImageAspectFlags aspectMask, VkImageLayout oldLayout, VkImageLayout newLayout, void *pNext = default) : this(image, oldLayout, newLayout, new VkImageSubresourceRange(aspectMask, 0, 1, 0, 1), pNext) { }
/// <summary> /// Starts building a new attachment for this render pass /// </summary> /// <param name="id">identifier for the attachment</param> /// <param name="format">attachment's format</param> /// <param name="finalLayout">attachment's final image layout</param> /// <param name="samples">attachment's sample count</param> /// <returns>attachment builder</returns> public AttachmentBuilder WithAttachment(TAttachment id, VkFormat format, VkImageLayout finalLayout, VkSampleCountFlag samples = VkSampleCountFlag.Count1) { Debug.Assert(!_attachmentOrder.Contains(id)); _attachmentOrder.Add(id); return(new AttachmentBuilder(this, id, format, finalLayout, samples)); }
protected void TransitionImageLayout(VkImage image, uint mipLevels, VkImageLayout oldLayout, VkImageLayout newLayout) { VkCommandBuffer cb = BeginOneTimeCommands(); VkImageMemoryBarrier barrier = VkImageMemoryBarrier.New(); barrier.oldLayout = oldLayout; barrier.newLayout = newLayout; barrier.srcQueueFamilyIndex = QueueFamilyIgnored; barrier.dstQueueFamilyIndex = QueueFamilyIgnored; barrier.image = image; barrier.subresourceRange.aspectMask = VkImageAspectFlags.Color; barrier.subresourceRange.baseMipLevel = 0; barrier.subresourceRange.levelCount = mipLevels; barrier.subresourceRange.baseArrayLayer = 0; barrier.subresourceRange.layerCount = 1; vkCmdPipelineBarrier( cb, VkPipelineStageFlags.TopOfPipe, VkPipelineStageFlags.TopOfPipe, VkDependencyFlags.None, 0, null, 0, null, 1, &barrier); EndOneTimeCommands(cb); }
public Cmd_CopyBufferToImage(SoftwareBuffer srcBuffer, SoftwareImage dstImage, VkImageLayout dstImageLayout, int regionCount, VkBufferImageCopy[] pRegions) { this.m_srcBuffer = srcBuffer; this.m_dstImage = dstImage; this.m_dstImageLayout = dstImageLayout; this.m_regionCount = regionCount; this.m_pRegions = pRegions; }
public static extern void CmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, ref VkClearDepthStencilValue pDepthStencil, uint rangeCount, IntPtr pRanges );
public static extern void CmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, ref VkClearColorValue pColor, uint rangeCount, IntPtr pRanges );
/// <inheritdoc/> public SubpassBuilder InputAttachment(TAttachment attachment, VkImageLayout layout) { _inputAttachmentReferences.Add(new LazyAttachmentReference() { Id = attachment, Layout = layout }); return(this); }
public static extern void CmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, IntPtr pRegions );
public static extern void CmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint regionCount, IntPtr pRegions );
void TransitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout) { var commandBuffer = BeginSingleTimeCommands(); var barrier = new VkImageMemoryBarrier(); barrier.oldLayout = oldLayout; barrier.newLayout = newLayout; barrier.srcQueueFamilyIndex = -1; //VK_QUEUE_FAMILY_IGNORED barrier.dstQueueFamilyIndex = -1; barrier.image = image; barrier.subresourceRange.aspectMask = VkImageAspectFlags.ColorBit; barrier.subresourceRange.baseMipLevel = 0; barrier.subresourceRange.levelCount = 1; barrier.subresourceRange.baseArrayLayer = 0; barrier.subresourceRange.layerCount = 1; VkPipelineStageFlags source; VkPipelineStageFlags dest; if (oldLayout == VkImageLayout.Undefined && newLayout == VkImageLayout.TransferSrcOptimal) { barrier.srcAccessMask = VkAccessFlags.HostWriteBit; barrier.dstAccessMask = VkAccessFlags.TransferReadBit; source = VkPipelineStageFlags.HostBit; dest = VkPipelineStageFlags.TransferBit; } else if (oldLayout == VkImageLayout.Undefined && newLayout == VkImageLayout.TransferDstOptimal) { barrier.srcAccessMask = VkAccessFlags.HostWriteBit; barrier.dstAccessMask = VkAccessFlags.TransferWriteBit; source = VkPipelineStageFlags.HostBit; dest = VkPipelineStageFlags.TransferBit; } else if (oldLayout == VkImageLayout.TransferDstOptimal && newLayout == VkImageLayout.ShaderReadOnlyOptimal) { barrier.srcAccessMask = VkAccessFlags.TransferWriteBit; barrier.dstAccessMask = VkAccessFlags.ShaderReadBit; source = VkPipelineStageFlags.TransferBit; dest = VkPipelineStageFlags.FragmentShaderBit; } else { throw new Exception("Unsupported transition"); } commandBuffer.PipelineBarrier( source, dest, VkDependencyFlags.None, null, null, new List <VkImageMemoryBarrier> { barrier }); EndSingleTimeCommand(commandBuffer); }
public void CmdClearDepthStencilImage( [FromProperty("this")] GenCommandBuffer commandBuffer, GenImage image, VkImageLayout imageLayout, VkClearDepthStencilValue *pDepthStencil, [CountFor("ranges")] int rangeCount, [IsArray] VkImageSubresourceRange *pRanges) { }
/// <inheritdoc/> public SubpassBuilder ResolveAttachment(uint attachment, VkImageLayout layout) { _resolveAttachmentReferences.Add(new VkAttachmentReference() { Attachment = attachment, Layout = layout }); return(this); }
public void TransferImageLayout(Image image, VkImageLayout newLayout) { for (uint i = 0; i < image.MipLevel; i++) { TransferImageLayout(image.Handle, image.Format, image.Layout[i], newLayout, i); } Array.Fill(image.Layout, newLayout); }
public void CmdCopyBufferToImage( [FromProperty("this")] GenCommandBuffer commandBuffer, GenBuffer srcBuffer, GenImage dstImage, VkImageLayout dstImageLayout, [CountFor("regions")] int regionCount, [IsArray] VkBufferImageCopy *pRegions) { }
public void ClearColorImage(Image image, VkImageLayout imageLayout, ref VkClearColorValue clearColor, List <VkImageSubresourceRange> ranges) { unsafe { var rangesNative = stackalloc VkImageSubresourceRange[ranges.Count]; Interop.Copy(ranges, (IntPtr)rangesNative); Device.Commands.cmdClearColorImage(commandBuffer, image.Native, imageLayout, ref clearColor, (uint)ranges.Count, (IntPtr)rangesNative); } }
public void CmdCopyImageToBuffer( [FromProperty("this")] GenCommandBuffer commandBuffer, GenImage srcImage, VkImageLayout srcImageLayout, GenBuffer dstBuffer, [CountFor("regions")] int regionCount, [IsArray] VkBufferImageCopy *pRegions) { }
/// <inheritdoc/> public SubpassBuilder ColorAttachment(TAttachment attachment, VkImageLayout layout = VkImageLayout.ColorAttachmentOptimal) { _colorAttachmentReferences.Add(new LazyAttachmentReference() { Id = attachment, Layout = layout }); return(this); }
public void CmdCopyBufferToImage(VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, int regionCount, VkBufferImageCopy[] pRegions) { if (m_State != CommandBufferState.Recording) { return; } m_Commands.Add(new Cmd_CopyBufferToImage((SoftwareBuffer)srcBuffer, (SoftwareImage)dstImage, dstImageLayout, regionCount, pRegions)); }
internal SoftwareSampler2D(VkImageLayout imageLayout, SoftwareImageView imageView, SoftwareSampler sampler) { this.imageLayout = imageLayout; this.imageView = imageView; this.sampler = sampler; this.m_Width = imageView.GetWidth(); this.m_Height = imageView.GetHeight(); }
public static extern void CmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, IntPtr pRegions );
public void CmdClearColorImage(VkImage Image, VkImageLayout ImageLayout, uint R, uint G, uint B, uint A, VkImageSubresourceRange[] Ranges) { VkClearValue.VkClearColorValue.UInt32_t color = new VkClearValue.VkClearColorValue.UInt32_t(); color.uint32 = new uint[4]; color.uint32[0] = R; color.uint32[1] = G; color.uint32[2] = B; color.uint32[3] = A; CmdClearColorImage(Image, ImageLayout, ref color, Ranges); }
public void CmdClearColorImage(VkImage Image, VkImageLayout ImageLayout, float R, float G, float B, float A, VkImageSubresourceRange[] Ranges) { VkClearValue.VkClearColorValue.Float color = new VkClearValue.VkClearColorValue.Float(); color.float32 = new float[4]; color.float32[0] = R; color.float32[1] = G; color.float32[2] = B; color.float32[3] = A; CmdClearColorImage(Image, ImageLayout, ref color, Ranges); }
public void CmdClearDepthStencilImage(IVkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue depthStencil, IReadOnlyList<VkImageSubresourceRange> ranges) { var unmanagedSize = ranges.SizeOfMarshalDirect(); var unmanagedArray = new byte[unmanagedSize]; fixed (byte* unmanagedStart = unmanagedArray) { var unmanaged = unmanagedStart; var _commandBuffer = Handle; var _image = image?.Handle ?? VkImage.HandleType.Null; var _imageLayout = imageLayout; var _pDepthStencil = &depthStencil; var _rangeCount = ranges?.Count ?? 0; var _pRanges = ranges.MarshalDirect(ref unmanaged); Direct.CmdClearDepthStencilImage(_commandBuffer, _image, _imageLayout, _pDepthStencil, _rangeCount, _pRanges); } }
public void CmdClearDepthStencilImage( [FromProperty("this")] GenCommandBuffer commandBuffer, GenImage image, VkImageLayout imageLayout, VkClearDepthStencilValue* pDepthStencil, [CountFor("ranges")] int rangeCount, [IsArray] VkImageSubresourceRange* pRanges) { }
public void CmdCopyBufferToImage( [FromProperty("this")] GenCommandBuffer commandBuffer, GenBuffer srcBuffer, GenImage dstImage, VkImageLayout dstImageLayout, [CountFor("regions")] int regionCount, [IsArray] VkBufferImageCopy* pRegions) { }
public void CmdCopyImageToBuffer( [FromProperty("this")] GenCommandBuffer commandBuffer, GenImage srcImage, VkImageLayout srcImageLayout, GenBuffer dstBuffer, [CountFor("regions")] int regionCount, [IsArray] VkBufferImageCopy* pRegions) { }
public void CmdBlitImage( [FromProperty("this")] GenCommandBuffer commandBuffer, GenImage srcImage, VkImageLayout srcImageLayout, GenImage dstImage, VkImageLayout dstImageLayout, [CountFor("regions")] int regionCount, [IsArray] VkImageBlit* pRegions, VkFilter filter) { }
public void CmdResolveImage( [FromProperty("this")] GenCommandBuffer commandBuffer, GenImage srcImage, VkImageLayout srcImageLayout, GenImage dstImage, VkImageLayout dstImageLayout, [CountFor("regions")] int regionCount, [IsArray] VkImageResolve* pRegions) { }
public void CmdResolveImage(IVkImage srcImage, VkImageLayout srcImageLayout, IVkImage dstImage, VkImageLayout dstImageLayout, IReadOnlyList<VkImageResolve> regions) { var unmanagedSize = regions.SizeOfMarshalDirect(); var unmanagedArray = new byte[unmanagedSize]; fixed (byte* unmanagedStart = unmanagedArray) { var unmanaged = unmanagedStart; var _commandBuffer = Handle; var _srcImage = srcImage?.Handle ?? VkImage.HandleType.Null; var _srcImageLayout = srcImageLayout; var _dstImage = dstImage?.Handle ?? VkImage.HandleType.Null; var _dstImageLayout = dstImageLayout; var _regionCount = regions?.Count ?? 0; var _pRegions = regions.MarshalDirect(ref unmanaged); Direct.CmdResolveImage(_commandBuffer, _srcImage, _srcImageLayout, _dstImage, _dstImageLayout, _regionCount, _pRegions); } }