From c0591ecb2411e51ad936268cc3868ac3b1cb1675 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Przemys=C5=82aw=20Gasi=C7=B9ski?= <przemek@gasinski.eu>
Date: Mon, 5 Aug 2024 17:54:40 +0200
Subject: [PATCH] Load textures

---
 assets/textures/test.png | Bin 0 -> 4337 bytes
 build.zig                |  13 +-
 build.zig.zon            |   4 +
 src/Mesh.zig             |   5 +-
 src/shaders/shader.frag  |   5 +-
 src/shaders/shader.vert  |   5 +-
 src/utilities.zig        | 160 +++++++++++++++----
 src/vulkan_renderer.zig  | 326 ++++++++++++++++++++++++++++++++++++---
 8 files changed, 462 insertions(+), 56 deletions(-)
 create mode 100644 assets/textures/test.png

diff --git a/assets/textures/test.png b/assets/textures/test.png
new file mode 100644
index 0000000000000000000000000000000000000000..72b5550af6ffaa8c6ac03dad473fbad63658306b
GIT binary patch
literal 4337
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
X=97)zRLQ)57$E!~RwmWwJpcSZm0qd&

literal 0
HcmV?d00001

diff --git a/build.zig b/build.zig
index 466a919..b4210d8 100644
--- a/build.zig
+++ b/build.zig
@@ -41,12 +41,23 @@ pub fn build(b: *std.Build) void {
     const zmath = b.dependency("zmath", .{});
     exe.root_module.addImport("zmath", zmath.module("root"));
 
+    // zigimg
+    const zigimg = b.dependency("zigimg", .{});
+    exe.root_module.addImport("zigimg", zigimg.module("zigimg"));
+
     // ---
 
     b.installArtifact(exe);
 
+    const exe_check = b.addExecutable(.{
+        .name = "vulkan-test",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
     const check = b.step("check", "Check if vulkan-test compiles");
-    check.dependOn(&exe.step);
+    check.dependOn(&exe_check.step);
 
     const run_cmd = b.addRunArtifact(exe);
 
diff --git a/build.zig.zon b/build.zig.zon
index 5c30a28..f20f1f2 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -13,6 +13,10 @@
         //     .url = "https://github.com/ikskuh/SDL.zig/archive/9663dc70c19b13afcb4b9f596c928d7b2838e548.tar.gz",
         //     .hash = "12202141beb92d68ef5088538ff761d5c3ecd2d4e11867c89fbbdcd9f814b8cba8ee",
         // },
+        .zigimg = .{
+            .url = "https://github.com/zigimg/zigimg/archive/d9dbbe22b5f7b5f1f4772169ed93ffeed8e8124d.tar.gz",
+            .hash = "122013646f7038ecc71ddf8a0d7de346d29a6ec40140af57f838b0a975c69af512b0",
+        },
     },
 
     .paths = .{
diff --git a/src/Mesh.zig b/src/Mesh.zig
index 0ba7b58..74e52d4 100644
--- a/src/Mesh.zig
+++ b/src/Mesh.zig
@@ -11,6 +11,7 @@ const Model = @import("vulkan_renderer.zig").Model;
 const Self = @This();
 
 ubo_model: Model,
+tex_id: u32,
 
 vertex_count: u32,
 vertex_buffer: vk.Buffer,
@@ -34,6 +35,7 @@ pub fn new(
     transfer_command_pool: vk.CommandPool,
     vertices: []const Vertex,
     indices: []const u32,
+    tex_id: u32,
     allocator: std.mem.Allocator,
 ) !Self {
     var self: Self = undefined;
@@ -50,6 +52,7 @@ pub fn new(
     try self.createIndexBuffer(transfer_queue, transfer_command_pool, indices);
 
     self.ubo_model = .{ .model = zm.identity() };
+    self.tex_id = tex_id;
 
     return self;
 }
@@ -122,7 +125,6 @@ fn createVertexBuffer(
         staging_buffer,
         self.vertex_buffer,
         buffer_size,
-        self.allocator,
     );
 }
 
@@ -178,6 +180,5 @@ fn createIndexBuffer(
         staging_buffer,
         self.index_buffer,
         buffer_size,
-        self.allocator,
     );
 }
diff --git a/src/shaders/shader.frag b/src/shaders/shader.frag
index 76d73d7..3c347a6 100644
--- a/src/shaders/shader.frag
+++ b/src/shaders/shader.frag
@@ -1,10 +1,13 @@
 #version 450
 
 layout(location = 0) in vec3 fragCol;
+layout(location = 1) in vec2 fragTex;
 
 // Final output output (must also have location)
 layout(location = 0) out vec4 outColour;
 
+layout(set = 1, binding = 0) uniform sampler2D textureSampler;
+
 void main() {
-    outColour = vec4(fragCol, 1.0);
+    outColour = texture(textureSampler, fragTex);
 }
diff --git a/src/shaders/shader.vert b/src/shaders/shader.vert
index baad5c6..04c6d1f 100644
--- a/src/shaders/shader.vert
+++ b/src/shaders/shader.vert
@@ -2,10 +2,12 @@
 
 layout(location = 0) in vec3 pos;
 layout(location = 1) in vec3 col;
+layout(location = 2) in vec2 tex;
 
 layout(location = 0) out vec3 fragCol;
+layout(location = 1) out vec2 fragTex;
 
-layout(binding = 0) uniform UboViewProjection {
+layout(set = 0, binding = 0) uniform UboViewProjection {
     mat4 projection;
     mat4 view;
 } uboViewProjection;
@@ -17,4 +19,5 @@ layout(push_constant) uniform PushModel {
 void main() {
     gl_Position = uboViewProjection.projection * uboViewProjection.view * pushModel.model * vec4(pos, 1.0);
     fragCol = col;
+    fragTex = tex;
 }
diff --git a/src/utilities.zig b/src/utilities.zig
index f9db076..94eed98 100644
--- a/src/utilities.zig
+++ b/src/utilities.zig
@@ -8,12 +8,13 @@ const CommandBuffer = @import("vulkan_renderer.zig").CommandBuffer;
 pub const device_extensions = [_][*:0]const u8{vk.extensions.khr_swapchain.name};
 
 pub const Vector3 = @Vector(3, f32);
+pub const Vector2 = @Vector(2, f32);
 
 // Vertex data representation
 pub const Vertex = struct {
-    // Vertex position (x, y, z)
-    pos: Vector3,
-    col: Vector3,
+    pos: Vector3, // Vertex position (x, y, z)
+    col: Vector3, // Vertex colour (r, g, b)
+    tex: Vector2, // Texture coords (u, v)
 };
 
 pub const QueueFamilyIndices = struct {
@@ -96,31 +97,20 @@ pub fn createBuffer(
     try device.bindBufferMemory(buffer.*, buffer_memory.*, 0);
 }
 
-pub fn copyBuffer(
-    device: Device,
-    transfer_queue: vk.Queue,
-    transfer_command_pool: vk.CommandPool,
-    src_buffer: vk.Buffer,
-    dst_buffer: vk.Buffer,
-    buffer_size: vk.DeviceSize,
-    allocator: std.mem.Allocator,
-) !void {
+fn beginCommandBuffer(device: Device, command_pool: vk.CommandPool) !CommandBuffer {
     // Command buffer to hold transfer commands
-    const transfer_command_buffer_handle = try allocator.create(vk.CommandBuffer);
-    defer allocator.destroy(transfer_command_buffer_handle);
-    // Free temporary buffer back to pool
-    defer device.freeCommandBuffers(transfer_command_pool, 1, @ptrCast(transfer_command_buffer_handle));
+    var command_buffer_handle: vk.CommandBuffer = undefined;
 
     // Command buffer details
     const alloc_info: vk.CommandBufferAllocateInfo = .{
-        .command_pool = transfer_command_pool,
+        .command_pool = command_pool,
         .level = .primary,
         .command_buffer_count = 1,
     };
 
     // Allocate command buffer from pool
-    try device.allocateCommandBuffers(&alloc_info, @ptrCast(transfer_command_buffer_handle));
-    const transfer_command_buffer = CommandBuffer.init(transfer_command_buffer_handle.*, device.wrapper);
+    try device.allocateCommandBuffers(&alloc_info, @ptrCast(&command_buffer_handle));
+    const command_buffer = CommandBuffer.init(command_buffer_handle, device.wrapper);
 
     // Information to begin the command buffer record
     const begin_info: vk.CommandBufferBeginInfo = .{
@@ -128,7 +118,39 @@ pub fn copyBuffer(
     };
 
     // Begin recording transfer commands
-    try transfer_command_buffer.beginCommandBuffer(&begin_info);
+    try command_buffer.beginCommandBuffer(&begin_info);
+
+    return command_buffer;
+}
+
+fn endAndSubmitCommandBuffer(device: Device, command_buffer: CommandBuffer, command_pool: vk.CommandPool, queue: vk.Queue) !void {
+    // End commands
+    try command_buffer.endCommandBuffer();
+
+    // Queue submission information
+    const submit_info: vk.SubmitInfo = .{
+        .command_buffer_count = 1,
+        .p_command_buffers = @ptrCast(&command_buffer.handle),
+    };
+
+    // Submit transfer command to transfer queue and wait until it finishes
+    try device.queueSubmit(queue, 1, @ptrCast(&submit_info), .null_handle);
+    try device.queueWaitIdle(queue);
+
+    // Free temporary buffer back to pool
+    device.freeCommandBuffers(command_pool, 1, @ptrCast(&command_buffer.handle));
+}
+
+pub fn copyBuffer(
+    device: Device,
+    transfer_queue: vk.Queue,
+    transfer_command_pool: vk.CommandPool,
+    src_buffer: vk.Buffer,
+    dst_buffer: vk.Buffer,
+    buffer_size: vk.DeviceSize,
+) !void {
+    // Create buffer
+    const transfer_command_buffer = try beginCommandBuffer(device, transfer_command_pool);
 
     // Region of data to copy from and to
     const buffer_copy_region: vk.BufferCopy = .{
@@ -140,16 +162,96 @@ pub fn copyBuffer(
     // Command to copy src buffer to dst buffer
     transfer_command_buffer.copyBuffer(src_buffer, dst_buffer, 1, @ptrCast(&buffer_copy_region));
 
-    // End commands
-    try transfer_command_buffer.endCommandBuffer();
+    // Command to copy src buffer to dst buffer
+    try endAndSubmitCommandBuffer(device, transfer_command_buffer, transfer_command_pool, transfer_queue);
+}
 
-    // Queue submission information
-    const submit_info: vk.SubmitInfo = .{
-        .command_buffer_count = 1,
-        .p_command_buffers = @ptrCast(&transfer_command_buffer.handle),
+pub fn copyImageBuffer(
+    device: Device,
+    transfer_queue: vk.Queue,
+    transfer_command_pool: vk.CommandPool,
+    src_buffer: vk.Buffer,
+    image: vk.Image,
+    width: u32,
+    height: u32,
+) !void {
+    const transfer_command_buffer = try beginCommandBuffer(device, transfer_command_pool);
+
+    const image_region: vk.BufferImageCopy = .{
+        .buffer_offset = 0, // Offset into data
+        .buffer_row_length = 0, // Row length of data to calculate data spacing
+        .buffer_image_height = 0, // Image height to calculate data spacing
+        .image_subresource = .{
+            .aspect_mask = .{ .color_bit = true }, // Which aspect of image to copy
+            .mip_level = 0, // Mipmap level to copy
+            .base_array_layer = 0, // Starting array layer (if array)
+            .layer_count = 1, // Number of layers of copy starting at base_array_layer
+        },
+        .image_offset = .{ .x = 0, .y = 0, .z = 0 }, // Offset to image (as opposed to raw data buffer offset)
+        .image_extent = .{ .width = width, .height = height, .depth = 1 }, // Size of the region to copy as x, y, z values
     };
 
-    // Submit transfer command to transfer queue and wait until it finishes
-    try device.queueSubmit(transfer_queue, 1, @ptrCast(&submit_info), .null_handle);
-    try device.queueWaitIdle(transfer_queue);
+    transfer_command_buffer.copyBufferToImage(src_buffer, image, .transfer_dst_optimal, 1, @ptrCast(&image_region));
+
+    try endAndSubmitCommandBuffer(device, transfer_command_buffer, transfer_command_pool, transfer_queue);
+}
+
+pub fn transitionImageLayout(
+    device: Device,
+    queue: vk.Queue,
+    command_pool: vk.CommandPool,
+    image: vk.Image,
+    old_layout: vk.ImageLayout,
+    new_layout: vk.ImageLayout,
+) !void {
+    const command_buffer = try beginCommandBuffer(device, command_pool);
+
+    var image_memory_barrier: vk.ImageMemoryBarrier = .{
+        .old_layout = old_layout, // Layout to transition from
+        .new_layout = new_layout, // Layout to transition to
+        .src_queue_family_index = vk.QUEUE_FAMILY_IGNORED, // Queue family to transition from
+        .dst_queue_family_index = vk.QUEUE_FAMILY_IGNORED, // Queue family to transition to
+        .image = image, // Image being accessed and modified as part of barrier
+        .subresource_range = .{
+            .aspect_mask = .{ .color_bit = true }, // Aspect of image being altered
+            .base_mip_level = 0, // First mip level to start alterations on
+            .level_count = 1, // Number of mipmap levels to alter starting from base mipmap level
+            .base_array_layer = 0, // First layer to start alterations on
+            .layer_count = 1, // Number of layers to alter starting from base array layer
+        },
+        .src_access_mask = .{}, // Memory access stage transition must happen after
+        .dst_access_mask = .{}, // Memory access stage transition must happen before
+    };
+
+    var src_stage: vk.PipelineStageFlags = .{};
+    var dst_stage: vk.PipelineStageFlags = .{};
+
+    // If transitioning from new image to image ready to receive data
+    if (old_layout == vk.ImageLayout.undefined and new_layout == vk.ImageLayout.transfer_dst_optimal) {
+        image_memory_barrier.dst_access_mask.transfer_write_bit = true;
+
+        src_stage.top_of_pipe_bit = true;
+        dst_stage.transfer_bit = true;
+    } else if (old_layout == vk.ImageLayout.transfer_dst_optimal and new_layout == vk.ImageLayout.shader_read_only_optimal) {
+        // If transitioning from transfer destination to shader readable
+        image_memory_barrier.src_access_mask.transfer_write_bit = true;
+        image_memory_barrier.dst_access_mask.shader_read_bit = true;
+
+        src_stage.transfer_bit = true;
+        dst_stage.fragment_shader_bit = true;
+    }
+
+    command_buffer.pipelineBarrier(
+        src_stage, // Pipeline stages (match to src and dst access mask)
+        dst_stage,
+        .{}, // Dependency flags
+        0, // Memory barrier count
+        null, // Memory barrier data
+        0, // Buffer memory barrier count
+        null, // Buffer memory barrier data
+        1, // Image memory barrier count
+        @ptrCast(&image_memory_barrier), // Image memory barrier data
+    );
+
+    try endAndSubmitCommandBuffer(device, command_buffer, command_pool, queue);
 }
diff --git a/src/vulkan_renderer.zig b/src/vulkan_renderer.zig
index 6a46d93..205662e 100644
--- a/src/vulkan_renderer.zig
+++ b/src/vulkan_renderer.zig
@@ -4,6 +4,7 @@ const vk = @import("vulkan");
 const builtin = @import("builtin");
 const shaders = @import("shaders");
 const zm = @import("zmath");
+const img = @import("zigimg");
 
 const Utilities = @import("utilities.zig");
 const QueueFamilyIndices = Utilities.QueueFamilyIndices;
@@ -74,6 +75,7 @@ pub const VulkanRenderer = struct {
     swapchain: vk.SwapchainKHR,
     viewport: vk.Viewport,
     scissor: vk.Rect2D,
+    texture_sampler: vk.Sampler,
 
     swapchain_images: []SwapchainImage,
     swapchain_framebuffers: []vk.Framebuffer,
@@ -85,14 +87,22 @@ pub const VulkanRenderer = struct {
 
     // Descriptors
     descriptor_set_layout: vk.DescriptorSetLayout,
+    sampler_set_layout: vk.DescriptorSetLayout,
     push_constant_range: vk.PushConstantRange,
 
     descriptor_pool: vk.DescriptorPool,
+    sampler_descriptor_pool: vk.DescriptorPool,
     descriptor_sets: []vk.DescriptorSet,
+    sampler_descriptor_sets: std.ArrayList(vk.DescriptorSet),
 
     vp_uniform_buffer: []vk.Buffer,
     vp_uniform_buffer_memory: []vk.DeviceMemory,
 
+    // Assets
+    texture_images: std.ArrayList(vk.Image),
+    texture_image_memory: std.ArrayList(vk.DeviceMemory),
+    texture_image_views: std.ArrayList(vk.ImageView),
+
     // Pipeline
     graphics_pipeline: vk.Pipeline,
     pipeline_layout: vk.PipelineLayout,
@@ -139,6 +149,19 @@ pub const VulkanRenderer = struct {
         try self.createFramebuffers();
         try self.createCommandPool();
 
+        try self.createCommandBuffers();
+        try self.createTextureSampler();
+        try self.createUniformBuffers();
+        try self.createDescriptorPool();
+        try self.createDescriptorSets();
+
+        try self.createSynchronisation();
+
+        self.texture_images = std.ArrayList(vk.Image).init(self.allocator);
+        self.texture_image_memory = std.ArrayList(vk.DeviceMemory).init(self.allocator);
+        self.texture_image_views = std.ArrayList(vk.ImageView).init(self.allocator);
+        self.sampler_descriptor_sets = std.ArrayList(vk.DescriptorSet).init(self.allocator);
+
         const aspect: f32 = @as(f32, @floatFromInt(self.extent.width)) / @as(f32, @floatFromInt(self.extent.height));
         self.ubo_view_projection.projection = zm.perspectiveFovRh(
             std.math.degreesToRadians(45.0),
@@ -158,17 +181,17 @@ pub const VulkanRenderer = struct {
         // Create meshes
         // Vertex Data
         var mesh_vertices = [_]Vertex{
-            .{ .pos = .{ -0.4, 0.4, 0.0 }, .col = .{ 1.0, 0.0, 0.0 } }, // 0
-            .{ .pos = .{ -0.4, -0.4, 0.0 }, .col = .{ 1.0, 0.0, 0.0 } }, // 1
-            .{ .pos = .{ 0.4, -0.4, 0.0 }, .col = .{ 1.0, 0.0, 0.0 } }, // 2
-            .{ .pos = .{ 0.4, 0.4, 0.0 }, .col = .{ 1.0, 0.0, 0.0 } }, // 3
+            .{ .pos = .{ -0.4, 0.4, 0.0 }, .col = .{ 1.0, 0.0, 0.0 }, .tex = .{ 1.0, 1.0 } }, // 0
+            .{ .pos = .{ -0.4, -0.4, 0.0 }, .col = .{ 1.0, 0.0, 0.0 }, .tex = .{ 1.0, 0.0 } }, // 1
+            .{ .pos = .{ 0.4, -0.4, 0.0 }, .col = .{ 1.0, 0.0, 0.0 }, .tex = .{ 0.0, 0.0 } }, // 2
+            .{ .pos = .{ 0.4, 0.4, 0.0 }, .col = .{ 1.0, 0.0, 0.0 }, .tex = .{ 0.0, 1.0 } }, // 3
         };
 
         var mesh_vertices2 = [_]Vertex{
-            .{ .pos = .{ -0.25, 0.6, 0.0 }, .col = .{ 0.0, 0.0, 1.0 } }, // 0
-            .{ .pos = .{ -0.25, -0.6, 0.0 }, .col = .{ 0.0, 0.0, 1.0 } }, // 1
-            .{ .pos = .{ 0.25, -0.6, 0.0 }, .col = .{ 0.0, 0.0, 1.0 } }, // 2
-            .{ .pos = .{ 0.25, 0.6, 0.0 }, .col = .{ 0.0, 0.0, 1.0 } }, // 3
+            .{ .pos = .{ -0.25, 0.6, 0.0 }, .col = .{ 0.0, 0.0, 1.0 }, .tex = .{ 1.0, 1.0 } }, // 0
+            .{ .pos = .{ -0.25, -0.6, 0.0 }, .col = .{ 0.0, 0.0, 1.0 }, .tex = .{ 1.0, 0.0 } }, // 1
+            .{ .pos = .{ 0.25, -0.6, 0.0 }, .col = .{ 0.0, 0.0, 1.0 }, .tex = .{ 0.0, 0.0 } }, // 2
+            .{ .pos = .{ 0.25, 0.6, 0.0 }, .col = .{ 0.0, 0.0, 1.0 }, .tex = .{ 0.0, 1.0 } }, // 3
         };
 
         // Index Data
@@ -185,6 +208,7 @@ pub const VulkanRenderer = struct {
             self.graphics_command_pool,
             &mesh_vertices,
             &mesh_indices,
+            try self.createTexture("test.png"),
             self.allocator,
         );
 
@@ -196,18 +220,12 @@ pub const VulkanRenderer = struct {
             self.graphics_command_pool,
             &mesh_vertices2,
             &mesh_indices,
+            try self.createTexture("test.png"),
             self.allocator,
         );
 
         self.meshes = [_]Mesh{ first_mesh, second_mesh };
 
-        try self.createCommandBuffers();
-        try self.createUniformBuffers();
-        try self.createDescriptorPool();
-        try self.createDescriptorSets();
-
-        try self.createSynchronisation();
-
         return self;
     }
 
@@ -280,12 +298,31 @@ pub const VulkanRenderer = struct {
             self.instance.destroyDebugUtilsMessengerEXT(self.debug_utils.?, null);
         }
 
+        self.device.destroySampler(self.texture_sampler, null);
+
+        for (
+            self.texture_images.items,
+            self.texture_image_memory.items,
+            self.texture_image_views.items,
+        ) |tex_image, tex_image_memory, tex_image_view| {
+            self.device.destroyImage(tex_image, null);
+            self.device.freeMemory(tex_image_memory, null);
+            self.device.destroyImageView(tex_image_view, null);
+        }
+
+        self.texture_images.deinit();
+        self.texture_image_memory.deinit();
+        self.texture_image_views.deinit();
+
         self.device.destroyImageView(self.depth_buffer_image_view, null);
         self.device.destroyImage(self.depth_buffer_image, null);
         self.device.freeMemory(self.depth_buffer_image_memory, null);
 
         self.device.destroyDescriptorPool(self.descriptor_pool, null);
         self.device.destroyDescriptorSetLayout(self.descriptor_set_layout, null);
+        self.device.destroyDescriptorPool(self.sampler_descriptor_pool, null);
+        self.device.destroyDescriptorSetLayout(self.sampler_set_layout, null);
+        self.sampler_descriptor_sets.deinit();
 
         for (0..self.swapchain_images.len) |i| {
             self.device.destroyBuffer(self.vp_uniform_buffer[i], null);
@@ -407,11 +444,17 @@ pub const VulkanRenderer = struct {
         else
             2;
 
+        // Device features
+        const device_features: vk.PhysicalDeviceFeatures = .{
+            .sampler_anisotropy = vk.TRUE, // Enable anisotropy
+        };
+
         const device_create_info: vk.DeviceCreateInfo = .{
             .queue_create_info_count = queue_count,
             .p_queue_create_infos = &qci,
             .pp_enabled_extension_names = &Utilities.device_extensions,
             .enabled_extension_count = @intCast(Utilities.device_extensions.len),
+            .p_enabled_features = &device_features,
         };
 
         const device_handle = try self.instance.createDevice(self.physical_device, &device_create_info, null);
@@ -595,6 +638,8 @@ pub const VulkanRenderer = struct {
     }
 
     fn createDescriptorSetLayout(self: *Self) !void {
+        // -- Uniform values descriptor set layout --
+
         // UboViewProjection binding info
         const vp_layout_binding: vk.DescriptorSetLayoutBinding = .{
             .binding = 0, // Binding point in shader (designated by binding number in shader)
@@ -614,6 +659,25 @@ pub const VulkanRenderer = struct {
 
         // Create descriptor set layout
         self.descriptor_set_layout = try self.device.createDescriptorSetLayout(&layout_create_info, null);
+
+        // -- Texture sampler descriptor set layout --
+
+        // Texture binding info
+        const sampler_layout_binding: vk.DescriptorSetLayoutBinding = .{
+            .binding = 0,
+            .descriptor_type = .combined_image_sampler,
+            .descriptor_count = 1,
+            .stage_flags = .{ .fragment_bit = true },
+            .p_immutable_samplers = null,
+        };
+
+        // Create a descriptor set layout with given bindings for texture
+        const texture_layout_info: vk.DescriptorSetLayoutCreateInfo = .{
+            .binding_count = 1,
+            .p_bindings = @ptrCast(&sampler_layout_binding),
+        };
+
+        self.sampler_set_layout = try self.device.createDescriptorSetLayout(&texture_layout_info, null);
     }
 
     fn createPushConstantRange(self: *Self) !void {
@@ -711,6 +775,13 @@ pub const VulkanRenderer = struct {
                 .format = vk.Format.r32g32b32_sfloat,
                 .offset = @offsetOf(Vertex, "col"),
             },
+            // Texture attribute
+            .{
+                .binding = 0,
+                .location = 2,
+                .format = vk.Format.r32g32_sfloat,
+                .offset = @offsetOf(Vertex, "tex"),
+            },
         };
 
         // -- Vertex input --
@@ -808,9 +879,11 @@ pub const VulkanRenderer = struct {
         };
 
         // -- Pipeline layout --
+        const descriptor_set_layouts = [_]vk.DescriptorSetLayout{ self.descriptor_set_layout, self.sampler_set_layout };
+
         const pipeline_layout_create_info: vk.PipelineLayoutCreateInfo = .{
-            .set_layout_count = 1,
-            .p_set_layouts = @ptrCast(&self.descriptor_set_layout),
+            .set_layout_count = @intCast(descriptor_set_layouts.len),
+            .p_set_layouts = &descriptor_set_layouts,
             .push_constant_range_count = 1,
             .p_push_constant_ranges = @ptrCast(&self.push_constant_range),
         };
@@ -925,6 +998,29 @@ pub const VulkanRenderer = struct {
         }
     }
 
+    fn createTextureSampler(self: *Self) !void {
+        // Sampler create info
+        const sampler_create_info: vk.SamplerCreateInfo = .{
+            .mag_filter = .linear, // How to render when image is magnified on screen
+            .min_filter = .linear, // How to render when image is minified on screen
+            .address_mode_u = .repeat, // How to handle texture wrap in U (x direction)
+            .address_mode_v = .repeat, // How to handle texture wrap in U (y direction)
+            .address_mode_w = .repeat, // How to handle texture wrap in U (z direction)
+            .border_color = .int_opaque_black, // Border beyond texture (only works for border clamp)
+            .unnormalized_coordinates = vk.FALSE, // Whether coords should be normalized (between 0 and 1)
+            .mipmap_mode = .linear, // Mipmap interpolation mode
+            .mip_lod_bias = 0.0, // Level of detail bias for mip level
+            .min_lod = 0.0, // Minimum lod to pick mip level
+            .max_lod = 0.0, // Maximum lod to pick mip level
+            .anisotropy_enable = vk.TRUE, // Enable anisotropy
+            .max_anisotropy = 16.0, // Anisotropy sample level
+            .compare_enable = vk.FALSE,
+            .compare_op = .never,
+        };
+
+        self.texture_sampler = try self.device.createSampler(&sampler_create_info, null);
+    }
+
     fn createUniformBuffers(self: *Self) !void {
         // View projection buffer size
         const vp_buffer_size: vk.DeviceSize = @sizeOf(UboViewProjection);
@@ -949,6 +1045,8 @@ pub const VulkanRenderer = struct {
     }
 
     fn createDescriptorPool(self: *Self) !void {
+        // -- Create uniform descriptor pool --
+
         // Type of descriptors + how many descriptors (!= descriptor sets) (combined makes the pool size)
         // View projection pool
         const vp_pool_size: vk.DescriptorPoolSize = .{
@@ -968,6 +1066,23 @@ pub const VulkanRenderer = struct {
 
         // Create descriptor pool
         self.descriptor_pool = try self.device.createDescriptorPool(&pool_create_info, null);
+
+        // -- Create sampler descriptor pool --
+
+        // Texture sampler pool
+        const sampler_pool_size: vk.DescriptorPoolSize = .{
+            .type = .combined_image_sampler,
+            .descriptor_count = MAX_OBJECTS,
+        };
+
+        // FIXME Not the best (look into array layers)
+        const sampler_pool_create_info: vk.DescriptorPoolCreateInfo = .{
+            .max_sets = MAX_OBJECTS,
+            .pool_size_count = 1,
+            .p_pool_sizes = @ptrCast(&sampler_pool_size),
+        };
+
+        self.sampler_descriptor_pool = try self.device.createDescriptorPool(&sampler_pool_create_info, null);
     }
 
     fn createDescriptorSets(self: *Self) !void {
@@ -1095,13 +1210,18 @@ pub const VulkanRenderer = struct {
                     @ptrCast(&mesh.ubo_model.model), // Actual data being pushed (can be array)
                 );
 
+                const descriptor_set_group = [_]vk.DescriptorSet{
+                    self.descriptor_sets[current_image],
+                    self.sampler_descriptor_sets.items[mesh.tex_id],
+                };
+
                 // Bind descriptor sets
                 command_buffer.bindDescriptorSets(
                     .graphics,
                     self.pipeline_layout,
                     0,
-                    1,
-                    @ptrCast(&self.descriptor_sets[current_image]),
+                    @intCast(descriptor_set_group.len),
+                    &descriptor_set_group,
                     0,
                     null,
                 );
@@ -1247,8 +1367,8 @@ pub const VulkanRenderer = struct {
             return false;
         }
 
+        const pdev_features = self.instance.getPhysicalDeviceFeatures(pdev);
         const queue_family_indices = self.getQueueFamilies(pdev) catch return false;
-
         const extension_support = self.checkDeviceExtensions(pdev) catch return false;
 
         const swapchain_details = self.getSwapchainDetails(pdev) catch return false;
@@ -1257,7 +1377,7 @@ pub const VulkanRenderer = struct {
 
         const swapchain_valid = swapchain_details.formats.len != 0 and swapchain_details.formats.len != 0;
 
-        return queue_family_indices.isValid() and extension_support and swapchain_valid;
+        return queue_family_indices.isValid() and extension_support and swapchain_valid and pdev_features.sampler_anisotropy == vk.TRUE;
     }
 
     fn checkValidationLayersSupport(self: Self) bool {
@@ -1376,6 +1496,168 @@ pub const VulkanRenderer = struct {
 
         return try self.device.createImageView(&image_view_create_info, null);
     }
+
+    fn createTextureImage(self: *Self, file_name: []const u8) !u32 {
+        // Load image file
+        var width: u32 = undefined;
+        var height: u32 = undefined;
+        var image_size: vk.DeviceSize = undefined;
+        const image = try self.loadTextureFile(file_name, &width, &height, &image_size);
+
+        // Create staging buffer to hold loaded data, ready to copy to device
+        var image_staging_buffer: vk.Buffer = undefined;
+        defer self.device.destroyBuffer(image_staging_buffer, null);
+        var image_staging_buffer_memory: vk.DeviceMemory = undefined;
+        defer self.device.freeMemory(image_staging_buffer_memory, null);
+
+        try Utilities.createBuffer(
+            self.physical_device,
+            self.instance,
+            self.device,
+            image_size,
+            .{ .transfer_src_bit = true },
+            .{ .host_visible_bit = true, .host_coherent_bit = true },
+            &image_staging_buffer,
+            &image_staging_buffer_memory,
+        );
+
+        // Copy data to staging buffer
+        const data = try self.device.mapMemory(image_staging_buffer_memory, 0, image_size, .{});
+        const image_data: *[]const u8 = @ptrCast(@alignCast(data));
+        image_data.* = image;
+        self.device.unmapMemory(image_staging_buffer_memory);
+
+        // Create image to hold final texture
+        var tex_image_memory: vk.DeviceMemory = undefined;
+        const tex_image: vk.Image = try self.createImage(
+            width,
+            height,
+            .r8g8b8a8_unorm,
+            .optimal,
+            .{ .transfer_dst_bit = true, .sampled_bit = true },
+            .{ .device_local_bit = true },
+            &tex_image_memory,
+        );
+
+        // Transition image to be DST for copy operation
+        try Utilities.transitionImageLayout(
+            self.device,
+            self.graphics_queue.handle,
+            self.graphics_command_pool,
+            tex_image,
+            .undefined,
+            .transfer_dst_optimal,
+        );
+
+        // Copy data to image
+        try Utilities.copyImageBuffer(
+            self.device,
+            self.graphics_queue.handle,
+            self.graphics_command_pool,
+            image_staging_buffer,
+            tex_image,
+            width,
+            height,
+        );
+
+        // Transition image to be shader readable for shader usage
+        try Utilities.transitionImageLayout(
+            self.device,
+            self.graphics_queue.handle,
+            self.graphics_command_pool,
+            tex_image,
+            .transfer_dst_optimal,
+            .shader_read_only_optimal,
+        );
+
+        // Add texture data to array for reference
+        try self.texture_images.append(tex_image);
+        try self.texture_image_memory.append(tex_image_memory);
+
+        // Return index of new texture image
+        return @intCast(self.texture_images.items.len - 1);
+    }
+
+    fn createTexture(self: *Self, file_name: []const u8) !u32 {
+        // Create texture image and get its location in the array
+        const texture_image_loc = try self.createTextureImage(file_name);
+
+        // Create image view and add to list
+        const image_view = try self.createImageView(
+            self.texture_images.items[texture_image_loc],
+            .r8g8b8a8_unorm,
+            .{ .color_bit = true },
+        );
+
+        try self.texture_image_views.append(image_view);
+
+        // Create texture descriptor
+        const descriptor_loc = try self.createTextureDescriptor(image_view);
+
+        // Return location of set with texture
+        return descriptor_loc;
+    }
+
+    fn createTextureDescriptor(self: *Self, texture_image: vk.ImageView) !u32 {
+        var descriptor_set: vk.DescriptorSet = undefined;
+
+        // Descriptor set allocation info
+        const set_alloc_info: vk.DescriptorSetAllocateInfo = .{
+            .descriptor_pool = self.sampler_descriptor_pool,
+            .descriptor_set_count = 1,
+            .p_set_layouts = @ptrCast(&self.sampler_set_layout),
+        };
+
+        // Allocate descriptor sets
+        try self.device.allocateDescriptorSets(&set_alloc_info, @ptrCast(&descriptor_set));
+
+        const image_info: vk.DescriptorImageInfo = .{
+            .image_layout = .shader_read_only_optimal, // Image layout when in use
+            .image_view = texture_image, // Image to bind to set
+            .sampler = self.texture_sampler, // Sampler to use for set
+        };
+
+        // Descriptor write info
+        const descriptor_write: vk.WriteDescriptorSet = .{
+            .dst_set = descriptor_set,
+            .dst_binding = 0,
+            .dst_array_element = 0,
+            .descriptor_type = .combined_image_sampler,
+            .descriptor_count = 1,
+            .p_image_info = @ptrCast(&image_info),
+            .p_buffer_info = undefined,
+            .p_texel_buffer_view = undefined,
+        };
+
+        // Update the new descriptor set
+        self.device.updateDescriptorSets(1, @ptrCast(&descriptor_write), 0, null);
+
+        try self.sampler_descriptor_sets.append(descriptor_set);
+
+        // Return descriptor set location
+        return @intCast(self.sampler_descriptor_sets.items.len - 1);
+    }
+
+    fn loadTextureFile(self: *Self, file_name: []const u8, width: *u32, height: *u32, image_size: *vk.DeviceSize) ![]const u8 {
+        const path_concat = [2][]const u8{ "./assets/textures/", file_name };
+        const path = try std.mem.concat(self.allocator, u8, &path_concat);
+        defer self.allocator.free(path);
+
+        var image = try img.Image.fromFilePath(self.allocator, path);
+        defer image.deinit();
+
+        if (!image.pixelFormat().isRgba()) {
+            try image.convert(.rgba32);
+        }
+
+        width.* = @intCast(image.width);
+        height.* = @intCast(image.height);
+
+        // Calculate image size using given and known data
+        image_size.* = width.* * height.* * 4;
+
+        return image.rawBytes();
+    }
 };
 
 // Format: VK_FORMAT_R8G8B8A8_UNORM (VK_FORMAT_B8G8R8A8_UNORM as backup)
@@ -1479,7 +1761,7 @@ fn debugCallback(
     const severity = getMessageSeverityLabel(message_severity);
     const message_type = getMessageTypeLabel(message_types);
 
-    std.debug.print("[{s}] ({s}): {s}\n", .{ severity, message_type, p_callback_data.?.p_message.? });
+    std.debug.print("[{s}] ({s}): {s}\n=====\n", .{ severity, message_type, p_callback_data.?.p_message.? });
     return vk.TRUE;
 }