wha t !

shaders/shader.frag.glsl

@@ -13,8 +13,7 @@ layout(location = 2) in vec2 uv;
 
 layout(location = 0) out vec4 outColor;
 
-layout(binding = 1) uniform sampler samp;
+layout(binding = 1) uniform sampler2D samp;
-layout(binding = 2) uniform texture2D textures[g_max_images];
 
 void main() {
     if (shapeType == PTK_COMPONENT_TYPE_ELLIPSE) {
@@ -23,7 +22,7 @@ void main() {
         }
     }
     if (shapeType == PTK_COMPONENT_TYPE_IMAGE) {
-        outColor = texture(sampler2D(textures[0], samp), uv);
+        outColor = texture(samp, uv);
     } else {
         outColor = vec4(fragColor, 1.0);
     }

src/ptk_vk/image.c

@@ -20,7 +20,7 @@ size_t g_image_count = 0;
 
 static PTK_LIST(VkImage) m_images;
 static PTK_LIST(VkDeviceMemory) m_image_memories;
-PTK_LIST(VkImageView) g_image_views;
+VkImageView g_image_view;
 VkSampler g_sampler;
 
 bool create_image(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags props, VkImage *image, VkDeviceMemory *image_memory) {
@@ -210,14 +210,34 @@ bool copy_buffer_to_image(VkBuffer buffer, VkImage image, uint32_t width, uint32
 }
 
 bool create_image_view(VkImage image) {
-    PTK_OPTION(VkImageView) image_view = vk_create_image_view(image, VK_FORMAT_R8G8B8A8_SRGB);
+    VK_TRY(false,
-
+        vkCreateImageView(
-    if (!image_view.exists) {
+            g_dev,
-        PTK_ERR("failed creating texture image view");
+            &(VkImageViewCreateInfo){
-        return false;
+                .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-    }
+                .pNext = NULL,
-
+                .flags = 0,
-    PTK_LIST_ADD(VkImageView, g_image_views, image_view.value);
+                .image = image,
+                .viewType = VK_IMAGE_VIEW_TYPE_2D,
+                .format = VK_FORMAT_R8G8B8A8_SRGB,
+                .components = (VkComponentMapping){
+                    .r = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    .g = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    .b = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    .a = VK_COMPONENT_SWIZZLE_IDENTITY,
+                },
+                .subresourceRange = (VkImageSubresourceRange){
+                    .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                    .baseMipLevel = 0,
+                    .levelCount = 1,
+                    .baseArrayLayer = 0,
+                    .layerCount = 1,
+                },
+            },
+            NULL,
+            &g_image_view
+        )
+    );
 
     return true;
 }
@@ -357,10 +377,8 @@ bool vk_create_image(const char *path) {
 
 void vk_image_cleanup(void) {
     vkDestroySampler(g_dev, g_sampler, NULL);
-    PTK_LIST_FOR_EACH(VkImageView, g_image_views, iv, {
+
-        vkDestroyImageView(g_dev, iv, NULL);
+    vkDestroyImageView(g_dev, g_image_view, NULL);
-    })
-    PTK_LIST_FREE(g_image_views);
 
     PTK_LIST_FOR_EACH(VkImage, m_images, i, {
         vkDestroyImage(g_dev, i, NULL);

src/ptk_vk/image.h

@@ -12,12 +12,10 @@
 #endif
 #include <GLFW/glfw3.h>
 
-PTK_LIST_DEFINE(VkImageView);
-
 extern const size_t g_max_images;
 
 extern size_t g_image_count;
-extern PTK_LIST(VkImageView) g_image_views;
+extern VkImageView g_image_view;
 extern VkSampler g_sampler;
 
 bool vk_create_image(const char *path);

src/ptk_vk/init.c

@@ -32,6 +32,7 @@ PTK_LIST_DEFINE(VkDescriptorSet);
 typedef const char *constcharptr;
 PTK_ARRAY_DEFINE(constcharptr);
 PTK_LIST_DEFINE(constcharptr);
+PTK_LIST_DEFINE(VkImageView);
 
 #ifdef DEBUG
 PTK_LIST_DEFINE(VkLayerProperties);
@@ -555,53 +556,42 @@ bool create_swapchain(void) {
     return true;
 }
 
-PTK_OPTION(VkImageView) vk_create_image_view(VkImage image, VkFormat format) {
-    VkImageView image_view;
-
-    VK_TRY(PTK_OPTION_NONE(VkImageView),
-        vkCreateImageView(
-            g_dev,
-            &(VkImageViewCreateInfo){
-                .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-                .pNext = NULL,
-                .flags = 0,
-                .image = image,
-                .viewType = VK_IMAGE_VIEW_TYPE_2D,
-                .format = format,
-                .components = (VkComponentMapping){
-                    .r = VK_COMPONENT_SWIZZLE_IDENTITY,
-                    .g = VK_COMPONENT_SWIZZLE_IDENTITY,
-                    .b = VK_COMPONENT_SWIZZLE_IDENTITY,
-                    .a = VK_COMPONENT_SWIZZLE_IDENTITY,
-                },
-                .subresourceRange = (VkImageSubresourceRange){
-                    .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-                    .baseMipLevel = 0,
-                    .levelCount = 1,
-                    .baseArrayLayer = 0,
-                    .layerCount = 1,
-                },
-            },
-            NULL,
-            &image_view
-        )
-    );
-
-    return PTK_OPTION_SOME(VkImageView, image_view);
-}
-
 bool create_image_views(void) {
     m_swapchain_image_views = PTK_LIST_NEW(VkImageView, m_swapchain_images.size);
 
     PTK_LIST_FOR_EACH(VkImage, m_swapchain_images, swapchain_image, {
-        PTK_OPTION(VkImageView) image_view = vk_create_image_view(swapchain_image, m_swapchain_image_format);
+        VkImageView image_view;
 
-        if (!image_view.exists) {
+        VK_TRY(false,
-            PTK_ERR("failed creating image view");
+            vkCreateImageView(
-            return false;
+                g_dev,
-        }
+                &(VkImageViewCreateInfo){
+                    .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+                    .pNext = NULL,
+                    .flags = 0,
+                    .image = swapchain_image,
+                    .viewType = VK_IMAGE_VIEW_TYPE_2D,
+                    .format = m_swapchain_image_format,
+                    .components = (VkComponentMapping){
+                        .r = VK_COMPONENT_SWIZZLE_IDENTITY,
+                        .g = VK_COMPONENT_SWIZZLE_IDENTITY,
+                        .b = VK_COMPONENT_SWIZZLE_IDENTITY,
+                        .a = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    },
+                    .subresourceRange = (VkImageSubresourceRange){
+                        .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                        .baseMipLevel = 0,
+                        .levelCount = 1,
+                        .baseArrayLayer = 0,
+                        .layerCount = 1,
+                    },
+                },
+                NULL,
+                &image_view
+            )
+        );
 
-        PTK_LIST_ADD(VkImageView, m_swapchain_image_views, image_view.value);
+        PTK_LIST_ADD(VkImageView, m_swapchain_image_views, image_view);
     })
 
     return true;
@@ -734,18 +724,11 @@ bool create_descriptor_set_layout(void) {
         },
         (VkDescriptorSetLayoutBinding){
             .binding = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
+            .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
             .descriptorCount = 1,
             .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
             .pImmutableSamplers = NULL,
         },
-        (VkDescriptorSetLayoutBinding){
-            .binding = 2,
-            .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-            .descriptorCount = g_max_images,
-            .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
-            .pImmutableSamplers = NULL,
-        },
     });
 
     VK_TRY(false,
@@ -1321,13 +1304,9 @@ bool create_descriptor_pool(void) {
             .descriptorCount = g_max_frames_in_flight,
         },
         (VkDescriptorPoolSize){
-            .type = VK_DESCRIPTOR_TYPE_SAMPLER,
+            .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
             .descriptorCount = g_max_frames_in_flight,
         },
-        (VkDescriptorPoolSize){
-            .type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-            .descriptorCount = g_max_frames_in_flight * g_max_images,
-        },
     });
 
     VK_TRY(false,
@@ -1350,77 +1329,44 @@ bool create_descriptor_pool(void) {
 }
 
 PTK_LIST_DEFINE(VkDescriptorSetLayout);
-PTK_LIST_DEFINE(VkWriteDescriptorSet);
+PTK_ARRAY_DEFINE(VkWriteDescriptorSet);
 
 void vk_update_descriptor_sets(void) {
-    VkDescriptorImageInfo image_infos[g_image_count];
-
-    PTK_DEBUG("g_image_count: %d", g_image_count);
-    for (size_t i = 0; i < g_image_count; ++i) {
-        image_infos[i] = (VkDescriptorImageInfo){
-            .sampler = VK_NULL_HANDLE,
-            .imageView = g_image_views.data[i],
-            .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        };
-    }
-
     for (size_t i = 0; i < g_max_frames_in_flight; ++i) {
-        PTK_LIST(VkWriteDescriptorSet) descriptor_writes = PTK_LIST_NEW(VkWriteDescriptorSet, 2);
+        PTK_ARRAY(VkWriteDescriptorSet) descriptor_writes = PTK_ARRAY_NEW(VkWriteDescriptorSet, {
-
+            (VkWriteDescriptorSet){
-        VkWriteDescriptorSet ubo_descriptor_write = (VkWriteDescriptorSet){
-            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-            .pNext = NULL,
-            .dstSet = m_descriptor_sets.data[i],
-            .dstBinding = 0,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-            .pImageInfo = NULL,
-            .pBufferInfo = &(VkDescriptorBufferInfo){
-                .buffer = m_uniform_buffers.data[i],
-                .offset = 0,
-                .range = sizeof(UniformBufferObject),
-            },
-            .pTexelBufferView = NULL,
-        };
-
-        PTK_LIST_ADD(VkWriteDescriptorSet, descriptor_writes, ubo_descriptor_write);
-
-        VkWriteDescriptorSet sampler_descriptor_write = (VkWriteDescriptorSet){
-            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-            .pNext = NULL,
-            .dstSet = m_descriptor_sets.data[i],
-            .dstBinding = 1,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
-            .pImageInfo = &(VkDescriptorImageInfo){
-                .sampler = g_sampler,
-                .imageView = VK_NULL_HANDLE,
-                .imageLayout = VK_IMAGE_LAYOUT_UNDEFINED,
-            },
-            .pBufferInfo = NULL,
-            .pTexelBufferView = NULL,
-        };
-
-        PTK_LIST_ADD(VkWriteDescriptorSet, descriptor_writes, sampler_descriptor_write);
-
-        if (g_image_count != 0) {
-            VkWriteDescriptorSet image_descriptor_write = (VkWriteDescriptorSet){
                 .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
                 .pNext = NULL,
                 .dstSet = m_descriptor_sets.data[i],
-                .dstBinding = 2,
+                .dstBinding = 0,
                 .dstArrayElement = 0,
-                .descriptorCount = g_image_count,
+                .descriptorCount = 1,
-                .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
+                .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-                .pImageInfo = image_infos,
+                .pImageInfo = NULL,
+                .pBufferInfo = &(VkDescriptorBufferInfo){
+                    .buffer = m_uniform_buffers.data[i],
+                    .offset = 0,
+                    .range = sizeof(UniformBufferObject),
+                },
+                .pTexelBufferView = NULL,
+            },
+            (VkWriteDescriptorSet){
+                .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+                .pNext = NULL,
+                .dstSet = m_descriptor_sets.data[i],
+                .dstBinding = 1,
+                .dstArrayElement = 0,
+                .descriptorCount = 1,
+                .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                .pImageInfo = &(VkDescriptorImageInfo){
+                    .sampler = g_sampler,
+                    .imageView = g_image_view,
+                    .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                },
                 .pBufferInfo = NULL,
                 .pTexelBufferView = NULL,
-            };
+            },
-
+        });
-            PTK_LIST_ADD(VkWriteDescriptorSet, descriptor_writes, image_descriptor_write);
-        }
 
         vkUpdateDescriptorSets(
             g_dev,
@@ -1429,8 +1375,6 @@ void vk_update_descriptor_sets(void) {
             0,
             NULL
         );
-
-        PTK_LIST_FREE(descriptor_writes);
     }
 }
 

src/ptk_vk/init.h

@@ -16,7 +16,6 @@ PTK_LIST_DEFINE(VkSemaphore);
 PTK_LIST_DEFINE(VkFence);
 PTK_OPTION_DEFINE(VkCommandBuffer);
 PTK_OPTION_DEFINE(uint32_t);
-PTK_OPTION_DEFINE(VkImageView);
 
 extern VkDevice g_dev;
 extern VkPhysicalDevice g_physical_dev;
@@ -51,8 +50,6 @@ PTK_OPTION(VkCommandBuffer) vk_begin_single_time_commands(void);
 
 bool vk_end_single_time_commands(VkCommandBuffer command_buffer);
 
-PTK_OPTION(VkImageView) vk_create_image_view(VkImage image, VkFormat format);
-
 void vk_update_descriptor_sets(void);
 
 void vk_cleanup(void);