public static VKImage FromBitmapData(BitmapData[] mipmaps, ImageUsages usages)
{
    var totalSize = 0L;
    foreach (var mip in mipmaps)
        totalSize += mip.Size;

    var stagingBuffer = VK.Device.CreateBuffer(new BufferCreateInfo(totalSize, BufferUsages.TransferSrc));
    var stagingMemReq = stagingBuffer.GetMemoryRequirements();
    var heapIndex = VK.PhysicalDeviceMemoryProperties.MemoryTypes.IndexOf(stagingMemReq.MemoryTypeBits, MemoryProperties.HostVisible);
    var stagingMemory = VK.Device.AllocateMemory(new MemoryAllocateInfo(stagingMemReq.Size, heapIndex));
    stagingBuffer.BindMemory(stagingMemory);

    var bufferCopyRegions = new BufferImageCopy[mipmaps.Length];
    var mipNum = 0;
    unsafe
    {
        var start = (byte*)stagingMemory.Map(0, stagingMemReq.Size);
        var dest = start;
        foreach (var mip in mipmaps)
        {
            var bufferOffset = (long)dest - (long)start;
            var src = (byte*)mip.Data;
            for (var i = 0; i < stagingMemReq.Size - 3; i += 4)
            {
                *(dest + 2) = *(src++);
                *(dest + 1) = *(src++);
                *(dest) = *(src++);
                *(dest + 3) = *(src++);
                dest += 4;
            }
            stagingMemory.Unmap();

            bufferCopyRegions[mipNum] = new BufferImageCopy
            {
                ImageSubresource = new ImageSubresourceLayers(ImageAspects.Color, mipNum, 0, 1),
                ImageExtent = new Extent3D(mip.Extent.Width, mip.Extent.Height, 1),
                BufferOffset = bufferOffset,
                BufferImageHeight = mip.Extent.Height,
                BufferRowLength = mip.Extent.Width
            };
            mipNum++;
        }
    }

    var image = VK.Device.CreateImage(new ImageCreateInfo
    {
        ImageType = ImageType.Image2D,
        Format = VK.ColorFormat,
        MipLevels = mipmaps.Length,
        ArrayLayers = 1,
        Samples = SampleCounts.Count1,
        Tiling = ImageTiling.Optimal,
        SharingMode = SharingMode.Exclusive,
        InitialLayout = ImageLayout.Undefined,
        Extent = new Extent3D(mipmaps[0].Extent.Width, mipmaps[0].Extent.Height, 1),
        Usage = usages | ImageUsages.TransferDst
    });

    var imageMemReq = image.GetMemoryRequirements();
    var imageHeapIndex = VK.PhysicalDeviceMemoryProperties.MemoryTypes.IndexOf(imageMemReq.MemoryTypeBits, MemoryProperties.DeviceLocal);
    var memory = VK.Device.AllocateMemory(new MemoryAllocateInfo(imageMemReq.Size, imageHeapIndex));
    image.BindMemory(memory);

    var subresourceRange = new ImageSubresourceRange(ImageAspects.Color, 0, mipmaps.Length, 0, 1);

    var cmdBuffer = VK.GraphicsCommandPool.AllocateBuffers(new CommandBufferAllocateInfo(CommandBufferLevel.Primary, 1))[0];
    cmdBuffer.Begin(new CommandBufferBeginInfo(CommandBufferUsages.OneTimeSubmit));
    cmdBuffer.CmdPipelineBarrier(PipelineStages.TopOfPipe, PipelineStages.Transfer,
        imageMemoryBarriers: new[]
        {
            new ImageMemoryBarrier(
                image, subresourceRange,
                0, Accesses.TransferWrite,
                ImageLayout.Undefined, ImageLayout.TransferDstOptimal)
        });
    cmdBuffer.CmdCopyBufferToImage(stagingBuffer, image, ImageLayout.TransferDstOptimal, bufferCopyRegions);
    if (usages.HasFlag(ImageUsages.Sampled))
    {
        cmdBuffer.CmdPipelineBarrier(PipelineStages.Transfer, PipelineStages.FragmentShader,
            imageMemoryBarriers: new[]
            {
                new ImageMemoryBarrier(
                    image, subresourceRange,
                    Accesses.TransferWrite, Accesses.ShaderRead,
                    ImageLayout.TransferDstOptimal, ImageLayout.ShaderReadOnlyOptimal)
            });
    }
    cmdBuffer.End();

    var fence = VK.Device.CreateFence();
    VK.GraphicsQueue.Submit(new SubmitInfo(commandBuffers: new[] { cmdBuffer }), fence);
    fence.Wait();

    fence.Dispose();
    stagingMemory.Dispose();
    stagingBuffer.Dispose();

    var mipmapExtents = new Extent2D[mipmaps.Length];
    for (var i = 0; i < mipmaps.Length; i++)
        mipmapExtents[i] = mipmaps[i].Extent;

    return new VKImage
    {
        Disposed = false,
        Image = image,
        MipmapExtents = mipmapExtents
    };
}