public static void vkGetImageMemoryRequirements(VkDevice device, VkImage image, out VkMemoryRequirements pMemoryRequirements)
{
VkPreconditions.CheckNull(device, nameof(device));
VkPreconditions.CheckNull(image, nameof(image));
GetDevice(device).GetImageMemoryRequirements(image, out pMemoryRequirements);
}
protected override void OnResize()
{
base.OnResize();
dev.WaitIdle();
vkvgSurf?.Dispose();
vkvgSurf = new vkvg.Surface(vkvgDev, (int)Width, (int)Height);
vkvgSurf.Clear();
VkImage srcImg = new VkImage((ulong)vkvgSurf.VkImage.ToInt64());
for (int i = 0; i < swapChain.ImageCount; ++i)
{
cmds[i] = cmdPool.AllocateCommandBuffer();
cmds[i].Start();
Utils.setImageLayout(cmds[i].Handle, swapChain.images[i].Handle, VkImageAspectFlags.Color,
VkImageLayout.Undefined, VkImageLayout.TransferDstOptimal,
VkPipelineStageFlags.BottomOfPipe, VkPipelineStageFlags.Transfer);
Utils.setImageLayout(cmds[i].Handle, srcImg, VkImageAspectFlags.Color,
VkImageLayout.ColorAttachmentOptimal, VkImageLayout.TransferSrcOptimal,
VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.Transfer);
VkImageSubresourceLayers imgSubResLayer = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
mipLevel = 0,
baseArrayLayer = 0,
layerCount = 1
};
VkImageCopy cregion = new VkImageCopy
{
srcSubresource = imgSubResLayer,
srcOffset = default,
protected void CopyImage(VkImage srcImage, uint srcMipLevel, uint srcArrayLayer, VkImage dstImage, uint dstMipLevel, uint dstArrayLayer, uint width, uint height)
{
VkImageSubresourceLayers srcSubresource = new VkImageSubresourceLayers();
srcSubresource.mipLevel = srcMipLevel;
srcSubresource.aspectMask = VkImageAspectFlags.Color;
srcSubresource.baseArrayLayer = srcArrayLayer;
srcSubresource.layerCount = 1;
VkImageSubresourceLayers dstSubresource = new VkImageSubresourceLayers();
dstSubresource.mipLevel = dstMipLevel;
dstSubresource.aspectMask = VkImageAspectFlags.Color;
dstSubresource.baseArrayLayer = dstArrayLayer;
dstSubresource.layerCount = 1;
VkImageCopy region = new VkImageCopy();
region.dstSubresource = dstSubresource;
region.srcSubresource = srcSubresource;
region.extent.width = width;
region.extent.height = height;
region.extent.depth = 1;
VkCommandBuffer copyCmd = BeginOneTimeCommands();
vkCmdCopyImage(copyCmd, srcImage, VkImageLayout.TransferSrcOptimal, dstImage, VkImageLayout.TransferDstOptimal, 1, ref region);
EndOneTimeCommands(copyCmd);
}
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 }
);
}
void CreateImage(int width, int height,
VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties,
out VkImage image, out VkDeviceMemory memory)
{
var info = new VkImageCreateInfo();
info.imageType = VkImageType._2D;
info.extent.width = width;
info.extent.height = height;
info.extent.depth = 1;
info.mipLevels = 1;
info.arrayLayers = 1;
info.format = format;
info.tiling = tiling;
info.initialLayout = VkImageLayout.Undefined;
info.usage = usage;
info.sharingMode = VkSharingMode.Exclusive;
info.samples = VkSampleCountFlags._1_Bit;
image = new VkImage(device, info);
var req = image.Requirements;
var allocInfo = new VkMemoryAllocateInfo();
allocInfo.allocationSize = req.size;
allocInfo.memoryTypeIndex = FindMemoryType(req.memoryTypeBits, properties);
memory = new VkDeviceMemory(device, allocInfo);
image.Bind(memory, 0);
}
void CopyBufferToImage(VkBuffer buffer, VkImage image, int width, int height)
{
VkCommandBuffer commandBuffer = BeginSingleTimeCommands();
VkBufferImageCopy region = new VkBufferImageCopy();
region.bufferOffset = 0;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.aspectMask = VkImageAspectFlags.ColorBit;
region.imageSubresource.mipLevel = 0;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageOffset = new VkOffset3D();
region.imageExtent = new VkExtent3D {
width = width,
height = height,
depth = 1
};
commandBuffer.CopyBufferToImage(buffer, image, VkImageLayout.TransferDstOptimal, new VkBufferImageCopy[] { region });
EndSingleTimeCommand(commandBuffer);
}
protected void TransitionImageLayout(VkImage image, uint mipLevels, uint baseArrayLayer, uint layerCount, 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 = baseArrayLayer;
barrier.subresourceRange.layerCount = layerCount;
vkCmdPipelineBarrier(
cb,
VkPipelineStageFlags.TopOfPipe,
VkPipelineStageFlags.TopOfPipe,
VkDependencyFlags.None,
0, null,
0, null,
1, &barrier);
EndOneTimeCommands(cb);
}
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)
{
}
public override VkResult CreateImage(VkImageCreateInfo pCreateInfo, out VkImage pImage)
{
VkResult result;
pImage = SoftwareImage.CreateImage(this, pCreateInfo, out result);
return(result);
}
internal VkTexture(
VkGraphicsDevice gd,
uint width,
uint height,
uint mipLevels,
uint arrayLayers,
VkFormat vkFormat,
TextureUsage usage,
TextureSampleCount sampleCount,
VkImage existingImage)
{
Debug.Assert(width > 0 && height > 0);
_gd = gd;
MipLevels = mipLevels;
Width = width;
Height = height;
Depth = 1;
VkFormat = vkFormat;
Format = VkFormats.VkToVdPixelFormat(VkFormat);
ArrayLayers = arrayLayers;
Usage = usage;
SampleCount = sampleCount;
VkSampleCount = VkFormats.VdToVkSampleCount(sampleCount);
_optimalImage = existingImage;
}
// Used to construct Swapchain textures.
internal VkTexture(
VkGraphicsDevice gd,
uint width,
uint height,
uint mipLevels,
uint arrayLayers,
VkFormat vkFormat,
TextureUsage usage,
TextureSampleCount sampleCount,
VkImage existingImage)
{
Debug.Assert(width > 0 && height > 0);
_gd = gd;
MipLevels = mipLevels;
_width = width;
_height = height;
_depth = 1;
VkFormat = vkFormat;
_format = VkFormats.VkToVdPixelFormat(VkFormat);
ArrayLayers = arrayLayers;
Usage = usage;
Type = TextureType.Texture2D;
SampleCount = sampleCount;
VkSampleCount = VkFormats.VdToVkSampleCount(sampleCount);
_optimalImage = existingImage;
_imageLayouts = new[] { VkImageLayout.Undefined };
ClearIfRenderTarget();
}
public FTexture(VkDevice device, VkPhysicalDevice physicalDevice, int cmdPoolID, VkQueue queue, string[] paths,
VkFormat format, int width, int height, uint mipLevels = 1)
{
MipLevels = mipLevels;
image = LoadTexture(device, physicalDevice, cmdPoolID, queue, paths, MipLevels);
imageView = CreateColourImageArrayView(device, image, paths.Length, format, MipLevels);
InitMips(device, queue, image, width, height, MipLevels, (uint)paths.Length, cmdPoolID);
}
public static extern void CmdClearColorImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
ref VkClearColorValue pColor,
uint rangeCount,
IntPtr pRanges
);
public static VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, int memoryOffset)
{
VkPreconditions.CheckNull(device, nameof(device));
VkPreconditions.CheckNull(image, nameof(image));
VkPreconditions.CheckNull(memory, nameof(memory));
return(GetDevice(device).BindImageMemory(image, memory, memoryOffset));
}
private VulkanImage(VulkanContext ctx, VkImage image, VkDeviceMemory memory, VkImageView view, VkFormat format)
{
Image = image;
Memory = memory;
View = view;
Format = format;
this.ctx = ctx;
}
public static extern void CmdCopyImageToBuffer(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
uint regionCount,
IntPtr pRegions
);
public static extern void CmdCopyBufferToImage(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint regionCount,
IntPtr pRegions
);
public static extern void CmdClearDepthStencilImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
ref VkClearDepthStencilValue pDepthStencil,
uint rangeCount,
IntPtr pRanges
);
protected override void GenerateMipmapsCore(Texture texture)
{
EnsureNoRenderPass();
VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(texture);
vkTex.TransitionImageLayout(_cb, 0, 1, 0, vkTex.ArrayLayers, VkImageLayout.TransferSrcOptimal);
vkTex.TransitionImageLayout(_cb, 1, vkTex.MipLevels - 1, 0, vkTex.ArrayLayers, VkImageLayout.TransferDstOptimal);
VkImage deviceImage = vkTex.OptimalDeviceImage;
uint blitCount = vkTex.MipLevels - 1;
VkImageBlit *regions = stackalloc VkImageBlit[(int)blitCount];
for (uint level = 1; level < vkTex.MipLevels; level++)
{
uint blitIndex = level - 1;
regions[blitIndex].srcSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
baseArrayLayer = 0,
layerCount = vkTex.ArrayLayers,
mipLevel = 0
};
regions[blitIndex].srcOffsets_0 = new VkOffset3D();
regions[blitIndex].srcOffsets_1 = new VkOffset3D {
x = (int)vkTex.Width, y = (int)vkTex.Height, z = (int)vkTex.Depth
};
regions[blitIndex].dstOffsets_0 = new VkOffset3D();
regions[blitIndex].dstSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
baseArrayLayer = 0,
layerCount = vkTex.ArrayLayers,
mipLevel = level
};
Util.GetMipDimensions(vkTex, level, out uint mipWidth, out uint mipHeight, out uint mipDepth);
regions[blitIndex].dstOffsets_1 = new VkOffset3D {
x = (int)mipWidth, y = (int)mipHeight, z = (int)mipDepth
};
}
vkCmdBlitImage(
_cb,
deviceImage, VkImageLayout.TransferSrcOptimal,
deviceImage, VkImageLayout.TransferDstOptimal,
blitCount, regions,
_gd.GetFormatFilter(vkTex.VkFormat));
if ((vkTex.Usage & TextureUsage.Sampled) != 0)
{
// This is somewhat ugly -- the transition logic does not handle different source layouts, so we do two batches.
vkTex.TransitionImageLayout(_cb, 0, 1, 0, vkTex.ArrayLayers, VkImageLayout.ShaderReadOnlyOptimal);
vkTex.TransitionImageLayout(_cb, 1, vkTex.MipLevels - 1, 0, vkTex.ArrayLayers, VkImageLayout.ShaderReadOnlyOptimal);
}
}
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 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));
}
public void CopyBufferToImage(VkBuffer buffer, VkImage image, VkBufferImageCopy copyData)
{
unsafe
{
var local = copyData;
VkCommandBuffer.vkCmdCopyBufferToImage(Handle, buffer, image, VkImageLayout.TransferDstOptimal, 1,
&local);
}
}
protected Image(Device dev, VkImage handle, VkFormat format, VkExtent3D size, uint mips, uint layers)
{
Device = dev;
Format = format;
Dimensions = size;
Handle = handle;
MipmapCount = mips;
LayerCount = layers;
}
public static extern void CmdResolveImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint regionCount,
IntPtr pRegions
);
public static extern void CmdBlitImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint regionCount,
IntPtr pRegions,
VkFilter filter
);
public void SetFullHandles(VkImage image, VkImageView attachmentView,
VkImageLayout layout, VkAccessFlags accessMask,
VkFormat nativeFormat, VkImageAspectFlags aspect)
{
NativeImage = image;
NativeColorAttachmentView = attachmentView;
NativeLayout = layout;
NativeAccessMask = accessMask;
NativeFormat = nativeFormat;
NativeImageAspect = aspect;
}
/// <inheritdoc/>
protected internal override void OnDestroyed()
{
if (ParentTexture != null || isNotOwningResources)
{
NativeImage = VkImage.Null;
NativeMemory = VkDeviceMemory.Null;
}
if (!isNotOwningResources)
{
if (NativeMemory != VkDeviceMemory.Null)
{
GraphicsDevice.Collect(NativeMemory);
NativeMemory = VkDeviceMemory.Null;
SharedHandle = IntPtr.Zero;
}
if (NativeImage != VkImage.Null)
{
GraphicsDevice.Collect(NativeImage);
NativeImage = VkImage.Null;
}
if (NativeBuffer != VkBuffer.Null)
{
GraphicsDevice.Collect(NativeBuffer);
NativeBuffer = VkBuffer.Null;
}
if (NativeImageView != VkImageView.Null)
{
GraphicsDevice.Collect(NativeImageView);
NativeImageView = VkImageView.Null;
}
if (NativeColorAttachmentView != VkImageView.Null)
{
GraphicsDevice.Collect(NativeColorAttachmentView);
NativeColorAttachmentView = VkImageView.Null;
}
if (NativeDepthStencilView != VkImageView.Null)
{
GraphicsDevice.Collect(NativeDepthStencilView);
NativeDepthStencilView = VkImageView.Null;
}
}
base.OnDestroyed();
}
private VkImageAspectFlags GetAspectFlags(
VkImage image,
VkFormat format,
VkImageLayout layout
)
{
if (layout == VkImageLayout.DepthStencilAttachmentOptimal)
{
return(VkImageAspectFlags.Depth);
}
else
{
return(VkImageAspectFlags.Color);
}
}
public static ReadOnlySpan <VkImage> vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain)
{
int swapchainImageCount = 0;
vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, null).CheckResult();
ReadOnlySpan <VkImage> swapchainImages = new VkImage[swapchainImageCount];
fixed(VkImage *swapchainImagesPtr = swapchainImages)
{
vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, swapchainImagesPtr).CheckResult();
}
return(swapchainImages);
}
public static Span <T> vkMapMemory <T>(VkDevice device, VkImage image, VkDeviceMemory memory, ulong offset = 0, ulong size = WholeSize, VkMemoryMapFlags flags = VkMemoryMapFlags.None) where T : unmanaged
{
void *pData;
vkMapMemory(device, memory, offset, size, flags, &pData).CheckResult();
if (size == WholeSize)
{
vkGetImageMemoryRequirements(device, image, out var memoryRequirements);
return(new Span <T>(pData, (int)memoryRequirements.size));
}
return(new Span <T>(pData, (int)size));
}
