internal static VulkanImage Texture2D(VulkanContext ctx, TextureData tex2D)
{
ulong size = (ulong)tex2D.Mipmaps[0].Size;
VkBuffer stagingBuffer;
var bufferCreateInfo = new VkBufferCreateInfo
{
sType = VkStructureType.BufferCreateInfo,
pNext = null,
size = (ulong)tex2D.Mipmaps[0].Size,
usage = VkBufferUsageFlags.TransferSrc
};
vkCreateBuffer(ctx.Device, &bufferCreateInfo, null, out stagingBuffer);
vkGetPhysicalDeviceMemoryProperties(ctx.PhysicalDevice, out VkPhysicalDeviceMemoryProperties memoryProperties);
vkGetBufferMemoryRequirements(ctx.Device, stagingBuffer, out VkMemoryRequirements stagingMemReq);
uint heapIndex = BufferHelper.GetMemoryTypeIndex(stagingMemReq.memoryTypeBits, VkMemoryPropertyFlags.HostVisible, memoryProperties);
VkMemoryAllocateInfo memAllocInfo = new VkMemoryAllocateInfo()
{
sType = VkStructureType.MemoryAllocateInfo,
pNext = null,
allocationSize = stagingMemReq.size,
memoryTypeIndex = heapIndex
};
VkDeviceMemory stagingMemory;
VkResult result = vkAllocateMemory(ctx.Device, &memAllocInfo, null, &stagingMemory);
result.CheckResult();
result = vkBindBufferMemory(ctx.Device, stagingBuffer, stagingMemory, 0);
result.CheckResult();
void *vertexPtr;
result = vkMapMemory(ctx.Device, stagingMemory, 0, (ulong)tex2D.Mipmaps[0].Size, 0, &vertexPtr);
result.CheckResult();
fixed(byte *dataPtr = &tex2D.Mipmaps[0].Data[0])
{
Buffer.MemoryCopy(dataPtr, vertexPtr, size, size);
}
vkUnmapMemory(ctx.Device, stagingMemory);
// Setup buffer copy regions for each mip level.
var bufferCopyRegions = new VkBufferImageCopy[tex2D.Mipmaps.Length]; // TODO: stackalloc
int offset = 0;
for (int i = 0; i < bufferCopyRegions.Length; i++)
{
// TODO: from VulkanCore, doesn't look correct (reassigns bufferCopyRegions in each loop)
bufferCopyRegions = new[]
{
new VkBufferImageCopy
{
imageSubresource = new VkImageSubresourceLayers(VkImageAspectFlags.Color, (uint)i, 0, 1),
imageExtent = tex2D.Mipmaps[0].Extent,
bufferOffset = (ulong)offset
}
};
offset += tex2D.Mipmaps[i].Size;
}
// Create optimal tiled target image.
var createInfo = new VkImageCreateInfo
{
sType = VkStructureType.ImageCreateInfo,
pNext = null,
imageType = VkImageType.Image2D,
format = tex2D.Format,
mipLevels = (uint)tex2D.Mipmaps.Length,
arrayLayers = 1,
samples = VkSampleCountFlags.Count1,
tiling = VkImageTiling.Optimal,
sharingMode = VkSharingMode.Exclusive,
initialLayout = VkImageLayout.Undefined,
extent = tex2D.Mipmaps[0].Extent,
usage = VkImageUsageFlags.Sampled | VkImageUsageFlags.TransferDst
};
VkImage image;
result = vkCreateImage(ctx.Device, &createInfo, null, out image);
result.CheckResult();
VkMemoryRequirements imageMemReq;
vkGetImageMemoryRequirements(ctx.Device, image, out imageMemReq);
vkGetPhysicalDeviceMemoryProperties(ctx.PhysicalDevice, out VkPhysicalDeviceMemoryProperties imageMemoryProperties);
uint imageHeapIndex = BufferHelper.GetMemoryTypeIndex(imageMemReq.memoryTypeBits, VkMemoryPropertyFlags.DeviceLocal, imageMemoryProperties);
var allocInfo = new VkMemoryAllocateInfo
{
sType = VkStructureType.MemoryAllocateInfo,
pNext = null,
allocationSize = imageMemReq.size,
memoryTypeIndex = imageHeapIndex,
};
VkDeviceMemory memory;
result = vkAllocateMemory(ctx.Device, &allocInfo, null, &memory);
result.CheckResult();
result = vkBindImageMemory(ctx.Device, image, memory, 0);
result.CheckResult();
var subresourceRange = new VkImageSubresourceRange(VkImageAspectFlags.Color, 0, (uint)tex2D.Mipmaps.Length, 0, 1);
// Copy the data from staging buffers to device local buffers.
var allocInfo2 = new VkCommandBufferAllocateInfo()
{
sType = VkStructureType.CommandBufferAllocateInfo,
commandPool = ctx.GraphicsCommandPool,
level = VkCommandBufferLevel.Primary,
commandBufferCount = 1,
};
VkCommandBuffer cmdBuffer;
vkAllocateCommandBuffers(ctx.Device, &allocInfo2, &cmdBuffer);
VkCommandBufferBeginInfo beginInfo = new VkCommandBufferBeginInfo()
{
sType = VkStructureType.CommandBufferBeginInfo,
flags = VkCommandBufferUsageFlags.OneTimeSubmit,
};
vkBeginCommandBuffer(cmdBuffer, &beginInfo);
VkImageMemoryBarrier imageMemoryBarrier = new VkImageMemoryBarrier
{
sType = VkStructureType.ImageMemoryBarrier,
pNext = null,
image = image,
subresourceRange = subresourceRange,
srcAccessMask = 0,
dstAccessMask = VkAccessFlags.TransferWrite,
oldLayout = VkImageLayout.Undefined,
newLayout = VkImageLayout.TransferDstOptimal,
srcQueueFamilyIndex = QueueFamilyIgnored,
dstQueueFamilyIndex = QueueFamilyIgnored
};
vkCmdPipelineBarrier(cmdBuffer, VkPipelineStageFlags.TopOfPipe, VkPipelineStageFlags.Transfer, VkDependencyFlags.None, 0, null, 0, null, 1, &imageMemoryBarrier);
fixed(VkBufferImageCopy *regionsPtr = bufferCopyRegions)
{
vkCmdCopyBufferToImage(cmdBuffer, stagingBuffer, image, VkImageLayout.TransferDstOptimal, (uint)bufferCopyRegions.Length, regionsPtr);
}
VkImageMemoryBarrier imageMemoryBarrier2 = new VkImageMemoryBarrier
{
sType = VkStructureType.ImageMemoryBarrier,
pNext = null,
image = image,
subresourceRange = subresourceRange,
srcAccessMask = VkAccessFlags.TransferWrite,
dstAccessMask = VkAccessFlags.ShaderRead,
oldLayout = VkImageLayout.TransferDstOptimal,
newLayout = VkImageLayout.ShaderReadOnlyOptimal,
srcQueueFamilyIndex = (uint)QueueFamilyIgnored,
dstQueueFamilyIndex = (uint)QueueFamilyIgnored
};
vkCmdPipelineBarrier(cmdBuffer, VkPipelineStageFlags.Transfer, VkPipelineStageFlags.FragmentShader, VkDependencyFlags.None, 0, null, 0, null, 1, &imageMemoryBarrier2);
vkEndCommandBuffer(cmdBuffer);
// Submit.
VkFenceCreateInfo fenceCreateInfo = new VkFenceCreateInfo
{
sType = VkStructureType.FenceCreateInfo,
pNext = null
};
VkFence fence;
result = vkCreateFence(ctx.Device, &fenceCreateInfo, null, out fence);
result.CheckResult();
var submitInfo = new VkSubmitInfo
{
sType = VkStructureType.SubmitInfo,
pNext = null,
commandBufferCount = 1,
pCommandBuffers = &cmdBuffer
};
vkQueueSubmit(ctx.GraphicsQueue, submitInfo, fence);
result = vkWaitForFences(ctx.Device, 1, &fence, false, ulong.MaxValue);
result.CheckResult();
// Cleanup staging resources.
vkDestroyFence(ctx.Device, fence, null);
vkFreeMemory(ctx.Device, stagingMemory, null);
vkDestroyBuffer(ctx.Device, stagingBuffer, null);
// Create image view.
VkImageViewCreateInfo imageViewCreateInfo = new VkImageViewCreateInfo()
{
sType = VkStructureType.ImageViewCreateInfo,
image = image,
viewType = VkImageViewType.Image2D,
format = tex2D.Format,
subresourceRange = subresourceRange
};
VkImageView view;
vkCreateImageView(ctx.Device, &imageViewCreateInfo, null, out view);
return(new VulkanImage(ctx, image, memory, view, tex2D.Format));
}
internal static VulkanImage Texture2D(VulkanContext ctx, TextureData tex2D)
{
Buffer stagingBuffer = ctx.Device.CreateBuffer(
new BufferCreateInfo(tex2D.Mipmaps[0].Size, BufferUsages.TransferSrc));
MemoryRequirements stagingMemReq = stagingBuffer.GetMemoryRequirements();
int heapIndex = ctx.MemoryProperties.MemoryTypes.IndexOf(
stagingMemReq.MemoryTypeBits, MemoryProperties.HostVisible);
DeviceMemory stagingMemory = ctx.Device.AllocateMemory(
new MemoryAllocateInfo(stagingMemReq.Size, heapIndex));
stagingBuffer.BindMemory(stagingMemory);
IntPtr ptr = stagingMemory.Map(0, stagingMemReq.Size);
Interop.Write(ptr, tex2D.Mipmaps[0].Data);
stagingMemory.Unmap();
// Setup buffer copy regions for each mip level.
var bufferCopyRegions = new BufferImageCopy[tex2D.Mipmaps.Length];
int offset = 0;
for (int i = 0; i < bufferCopyRegions.Length; i++)
{
bufferCopyRegions = new[]
{
new BufferImageCopy
{
ImageSubresource = new ImageSubresourceLayers(ImageAspects.Color, i, 0, 1),
ImageExtent = tex2D.Mipmaps[0].Extent,
BufferOffset = offset
}
};
offset += tex2D.Mipmaps[i].Size;
}
// Create optimal tiled target image.
Image image = ctx.Device.CreateImage(new ImageCreateInfo
{
ImageType = ImageType.Image2D,
Format = tex2D.Format,
MipLevels = tex2D.Mipmaps.Length,
ArrayLayers = 1,
Samples = SampleCounts.Count1,
Tiling = ImageTiling.Optimal,
SharingMode = SharingMode.Exclusive,
InitialLayout = ImageLayout.Undefined,
Extent = tex2D.Mipmaps[0].Extent,
Usage = ImageUsages.Sampled | ImageUsages.TransferDst
});
MemoryRequirements imageMemReq = image.GetMemoryRequirements();
int imageHeapIndex = ctx.MemoryProperties.MemoryTypes.IndexOf(
imageMemReq.MemoryTypeBits, MemoryProperties.DeviceLocal);
DeviceMemory memory = ctx.Device.AllocateMemory(new MemoryAllocateInfo(imageMemReq.Size, imageHeapIndex));
image.BindMemory(memory);
var subresourceRange = new ImageSubresourceRange(ImageAspects.Color, 0, tex2D.Mipmaps.Length, 0, 1);
// Copy the data from staging buffers to device local buffers.
CommandBuffer cmdBuffer = ctx.GraphicsCommandPool.AllocateBuffers(new CommandBufferAllocateInfo(CommandBufferLevel.Primary, 1))[0];
cmdBuffer.Begin(new CommandBufferBeginInfo(CommandBufferUsages.OneTimeSubmit));
cmdBuffer.CmdPipelineBarrier(PipelineStages.TopOfPipe, PipelineStages.TopOfPipe,
imageMemoryBarriers: new[]
{
new ImageMemoryBarrier(
image, subresourceRange,
0, Accesses.TransferWrite,
ImageLayout.Undefined, ImageLayout.TransferDstOptimal)
});
cmdBuffer.CmdCopyBufferToImage(stagingBuffer, image, ImageLayout.TransferDstOptimal, bufferCopyRegions);
cmdBuffer.CmdPipelineBarrier(PipelineStages.TopOfPipe, PipelineStages.TopOfPipe,
imageMemoryBarriers: new[]
{
new ImageMemoryBarrier(
image, subresourceRange,
Accesses.TransferWrite, Accesses.ShaderRead,
ImageLayout.TransferDstOptimal, ImageLayout.ShaderReadOnlyOptimal)
});
cmdBuffer.End();
// Submit.
Fence fence = ctx.Device.CreateFence();
ctx.GraphicsQueue.Submit(new SubmitInfo(commandBuffers: new[] { cmdBuffer }), fence);
fence.Wait();
// Cleanup staging resources.
fence.Dispose();
stagingMemory.Dispose();
stagingBuffer.Dispose();
// Create image view.
ImageView view = image.CreateView(new ImageViewCreateInfo(tex2D.Format, subresourceRange));
return(new VulkanImage(image, memory, view, tex2D.Format));
}