WIP images

Author: karnkaul

guide/src/SUMMARY.md

@@ -42,3 +42,4 @@
   - [Vertex Buffer](memory/vertex_buffer.md)
   - [Command Block](memory/command_block.md)
   - [Device Buffers](memory/device_buffers.md)
+  - [Images](memory/images.md)

guide/src/memory/images.md

@@ -0,0 +1,83 @@
+# Images
+
+Images have a lot more properties and creation parameters than buffers. We shall constrain ourselves to just two kinds: sampled images (textures) for shaders, and depth images for rendering. For now add the foundation types and functions:
+
+```cpp
+struct RawImage {
+  auto operator==(RawImage const& rhs) const -> bool = default;
+
+  VmaAllocator allocator{};
+  VmaAllocation allocation{};
+  vk::Image image{};
+  vk::Extent2D extent{};
+  vk::Format format{};
+  std::uint32_t levels{};
+};
+
+struct ImageDeleter {
+  void operator()(RawImage const& raw_image) const noexcept;
+};
+
+using Image = Scoped<RawImage, ImageDeleter>;
+
+struct ImageCreateInfo {
+  VmaAllocator allocator;
+  std::uint32_t queue_family;
+};
+
+[[nodiscard]] auto create_image(ImageCreateInfo const& create_info,
+                                vk::ImageUsageFlags usage, std::uint32_t levels,
+                                vk::Format format, vk::Extent2D extent)
+  -> Image;
+```
+
+Implementation:
+
+```cpp
+void ImageDeleter::operator()(RawImage const& raw_image) const noexcept {
+  vmaDestroyImage(raw_image.allocator, raw_image.image, raw_image.allocation);
+}
+
+// ...
+auto vma::create_image(ImageCreateInfo const& create_info,
+                       vk::ImageUsageFlags const usage,
+                       std::uint32_t const levels, vk::Format const format,
+                       vk::Extent2D const extent) -> Image {
+  if (extent.width == 0 || extent.height == 0) {
+    std::println(stderr, "Images cannot have 0 width or height");
+    return {};
+  }
+  auto image_ci = vk::ImageCreateInfo{};
+  image_ci.setImageType(vk::ImageType::e2D)
+    .setExtent({extent.width, extent.height, 1})
+    .setFormat(format)
+    .setUsage(usage)
+    .setArrayLayers(1)
+    .setMipLevels(levels)
+    .setSamples(vk::SampleCountFlagBits::e1)
+    .setTiling(vk::ImageTiling::eOptimal)
+    .setInitialLayout(vk::ImageLayout::eUndefined)
+    .setQueueFamilyIndices(create_info.queue_family);
+  auto const vk_image_ci = static_cast<VkImageCreateInfo>(image_ci);
+
+  auto allocation_ci = VmaAllocationCreateInfo{};
+  allocation_ci.usage = VMA_MEMORY_USAGE_AUTO;
+  VkImage image{};
+  VmaAllocation allocation{};
+  auto const result = vmaCreateImage(create_info.allocator, &vk_image_ci,
+                     &allocation_ci, &image, &allocation, {});
+  if (result != VK_SUCCESS) {
+    std::println(stderr, "Failed to create VMA Image");
+    return {};
+  }
+
+  return RawImage{
+    .allocator = create_info.allocator,
+    .allocation = allocation,
+    .image = image,
+    .extent = extent,
+    .format = format,
+    .levels = levels,
+  };
+}
+```

src/vma.cpp

@@ -13,6 +13,10 @@ void BufferDeleter::operator()(RawBuffer const& raw_buffer) const noexcept {
 	vmaDestroyBuffer(raw_buffer.allocator, raw_buffer.buffer,
 					 raw_buffer.allocation);
 }
+
+void ImageDeleter::operator()(RawImage const& raw_image) const noexcept {
+	vmaDestroyImage(raw_image.allocator, raw_image.image, raw_image.allocation);
+}
 } // namespace vma
 
 auto vma::create_allocator(vk::Instance const instance,
@@ -130,19 +134,21 @@ auto vma::create_device_buffer(BufferCreateInfo const& create_info,
 	return ret;
 }
 
-auto vma::create_image(VmaAllocator allocator,
-					   ImageCreateInfo const& create_info) -> Image {
-	if (create_info.extent.width == 0 || create_info.extent.height == 0) {
+auto vma::create_image(ImageCreateInfo const& create_info,
+					   vk::ImageUsageFlags const usage,
+					   std::uint32_t const levels, vk::Format const format,
+					   vk::Extent2D const extent) -> Image {
+	if (extent.width == 0 || extent.height == 0) {
 		std::println(stderr, "Images cannot have 0 width or height");
 		return {};
 	}
 	auto image_ci = vk::ImageCreateInfo{};
 	image_ci.setImageType(vk::ImageType::e2D)
-		.setExtent({create_info.extent.width, create_info.extent.height, 1})
-		.setFormat(create_info.format)
-		.setUsage(create_info.usage)
+		.setExtent({extent.width, extent.height, 1})
+		.setFormat(format)
+		.setUsage(usage)
 		.setArrayLayers(1)
-		.setMipLevels(create_info.levels)
+		.setMipLevels(levels)
 		.setSamples(vk::SampleCountFlagBits::e1)
 		.setTiling(vk::ImageTiling::eOptimal)
 		.setInitialLayout(vk::ImageLayout::eUndefined)
@@ -153,20 +159,20 @@ auto vma::create_image(VmaAllocator allocator,
 	allocation_ci.usage = VMA_MEMORY_USAGE_AUTO;
 	VkImage image{};
 	VmaAllocation allocation{};
-	auto const result = vmaCreateImage(allocator, &vk_image_ci, &allocation_ci,
-									   &image, &allocation, {});
+	auto const result = vmaCreateImage(create_info.allocator, &vk_image_ci,
+									   &allocation_ci, &image, &allocation, {});
 	if (result != VK_SUCCESS) {
 		std::println(stderr, "Failed to create VMA Image");
 		return {};
 	}
 
 	return RawImage{
-		.allocator = allocator,
+		.allocator = create_info.allocator,
 		.allocation = allocation,
 		.image = image,
-		.extent = create_info.extent,
-		.format = create_info.format,
-		.levels = create_info.levels,
+		.extent = extent,
+		.format = format,
+		.levels = levels,
 	};
 }
 } // namespace lvk

src/vma.hpp

@@ -73,13 +73,12 @@ struct ImageDeleter {
 using Image = Scoped<RawImage, ImageDeleter>;
 
 struct ImageCreateInfo {
+	VmaAllocator allocator;
 	std::uint32_t queue_family;
-	vk::ImageUsageFlags usage;
-	vk::Format format;
-	vk::Extent2D extent;
-	std::uint32_t levels;
 };
 
-[[nodiscard]] auto create_image(VmaAllocator allocator,
-								ImageCreateInfo const& create_info) -> Image;
+[[nodiscard]] auto create_image(ImageCreateInfo const& create_info,
+								vk::ImageUsageFlags usage, std::uint32_t levels,
+								vk::Format format, vk::Extent2D extent)
+	-> Image;
 } // namespace lvk::vma