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;
}
private SoftwareImage(SoftwareDevice device, VkFormat format, VkExtent3D imageExtent, VkColorSpaceKHR colorSpace, out VkResult result)
{
this.m_device = device;
this.m_imageFormat = format;
this.m_imageExtent = imageExtent;
this.m_imageColorSpace = colorSpace;
Initialize(out result);
}
internal QueueFamily(VkQueueFamilyProperties prop, PhysicalDevice pDevice, uint index)
{
this.pDevice = pDevice;
this.index = index;
Flags = prop.queueFlags;
QueueCount = prop.queueCount;
TimestampValidBits = prop.timestampValidBits;
MinImageTransferGranularity = prop.minImageTransferGranularity;
}
private SoftwareImage(SoftwareDevice device, VkSwapchainCreateInfoKHR createInfo, out VkResult result)
{
this.m_device = device;
this.m_imageFormat = createInfo.imageFormat;
this.m_imageExtent = VkExtent3D.Create(createInfo.imageExtent.width, createInfo.imageExtent.height, 1);
this.m_imageColorSpace = createInfo.imageColorSpace;
Initialize(out result);
}
private SoftwareImage(SoftwareDevice device, VkImageCreateInfo pCreateInfo, out VkResult result)
{
this.m_device = device;
this.m_createInfo = pCreateInfo;
this.m_imageFormat = pCreateInfo.format;
this.m_imageExtent = pCreateInfo.extent;
this.m_imageColorSpace = VkColorSpaceKHR.VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
Initialize(out result);
}
public ImagePooled(Device dev, VkFormat format, VkImageType type, VkExtent3D size, uint mipLevels,
uint arrayLayers, VkImageTiling tiling, VkSampleCountFlag samples, VkImageUsageFlag usage,
VkImageCreateFlag flags, VkSharingMode sharing = VkSharingMode.Exclusive, uint[] sharedQueueFamily = null) :
base(dev, format, type, size, mipLevels, arrayLayers, tiling, samples, usage, flags, sharing,
sharedQueueFamily)
{
var memReq = MemoryRequirements;
var memType = memReq.FindMemoryType(dev.PhysicalDevice);
Memory = dev.MemoryPool.Allocate(memType, DeviceMemoryPools.Pool.TexturePool, memReq.TypeRequirements.Size);
BindMemory(Memory.BackingMemory, Memory.Offset);
}
internal void copy_buffer_to_image(Buffer src, Image image, ulong buffer_offset, VkOffset3D offset, VkExtent3D extent, uint row_length, uint slice_height, VkImageSubresourceLayers subresource)
{
VkBufferImageCopy region = new()
{
bufferOffset = buffer_offset,
bufferRowLength = row_length,
bufferImageHeight = slice_height,
imageSubresource = subresource,
imageOffset = offset,
imageExtent = extent,
};
vkCmdCopyBufferToImage(handle, src.handle, image.handle, image.get_layout(VkImageLayout.TransferSrcOptimal), 1, ®ion);
}
public static SoftwareImage CreateSwapchainImage(SoftwareDevice device, VkSwapchainCreateInfoKHR swapchainInfo, out VkResult result)
{
VkImageCreateInfo createInfo = new VkImageCreateInfo();
createInfo.extent = VkExtent3D.Create(swapchainInfo.imageExtent.width, swapchainInfo.imageExtent.height, 1);
createInfo.format = swapchainInfo.imageFormat;
createInfo.imageType = VkImageType.VK_IMAGE_TYPE_2D;
createInfo.arrayLayers = swapchainInfo.imageArrayLayers;
createInfo.sharingMode = swapchainInfo.imageSharingMode;
createInfo.usage = VkImageUsageFlags.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VkImageUsageFlags.VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
createInfo.samples = VkSampleCountFlagBits.VK_SAMPLE_COUNT_1_BIT;
createInfo.mipLevels = 1;
createInfo.initialLayout = VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED;
return(new SoftwareImage(device, createInfo, out result));
}
private void copy_image(Image dst, Image src, VkOffset3D dst_offset,
VkOffset3D src_offset, VkExtent3D extent,
VkImageSubresourceLayers dst_subresource,
VkImageSubresourceLayers src_subresource)
{
VkImageCopy region = new()
{
dstOffset = dst_offset,
srcOffset = src_offset,
extent = extent,
srcSubresource = src_subresource,
dstSubresource = dst_subresource,
};
vkCmdCopyImage(handle, src.handle, src.get_layout(VkImageLayout.TransferSrcOptimal), dst.handle, dst.get_layout(VkImageLayout.TransferDstOptimal), 1, ®ion);
}
public Image(Device dev, VkFormat format, VkImageType type, VkExtent3D size, uint mipLevels, uint arrayLayers,
VkImageTiling tiling, VkSampleCountFlag samples, VkImageUsageFlag usage, VkImageCreateFlag flags,
VkSharingMode sharing = VkSharingMode.Exclusive,
uint[] sharedQueueFamily = null)
{
Device = dev;
Format = format;
Dimensions = size;
MipmapCount = mipLevels;
LayerCount = arrayLayers;
unsafe
{
#if DEBUG
var properties = Device.PhysicalDevice.Handle.GetPhysicalDeviceImageFormatProperties(format, type,
tiling, usage, flags);
#endif
if (sharing == VkSharingMode.Concurrent)
Debug.Assert(sharedQueueFamily != null);
fixed(uint *sharedPtr = sharedQueueFamily)
{
var info = new VkImageCreateInfo()
{
SType = VkStructureType.ImageCreateInfo,
Format = format,
ImageType = type,
Tiling = tiling,
Extent = size,
ArrayLayers = arrayLayers,
MipLevels = mipLevels,
Flags = flags,
InitialLayout = VkImageLayout.Undefined,
PNext = IntPtr.Zero,
PQueueFamilyIndices = sharedPtr,
SharingMode = sharing,
Samples = samples,
Usage = usage
};
Handle = Device.Handle.CreateImage(&info, Instance.AllocationCallbacks);
}
}
}
public ref VirtualTexturePage AddPage(VkOffset3D offset, VkExtent3D extent, ulong size, uint mipLevel, uint layer)
{
VirtualTexturePage newPage = new VirtualTexturePage
{
offset = offset,
extent = extent,
size = size,
mipLevel = mipLevel,
layer = layer,
index = (uint)pages.Count,
imageMemoryBind = new VkSparseImageMemoryBind()
{
offset = offset,
extent = extent,
}
};
pages.Add(newPage);
return(ref pages.Back());
}
public static VkQueueFamilyProperties Create(int queueCount, VkQueueFlagBits queueFlags)
{
return(new VkQueueFamilyProperties()
{
queueCount = queueCount, queueFlags = queueFlags, minImageTransferGranularity = VkExtent3D.Create(1, 1, 1)
});
}
