MetzNet
/
spacegame
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added QueueStruct for holding VkQueue + family + index

main
noah metz 2024-01-16 15:09:33 -07:00
parent 007520a92c
commit 11c135d696
3 changed files with 154 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
Unescape Escape View File

@ -1,6 +1,6 @@
ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST)))) ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
CFLAGS = -fsanitize=address -I $(ROOT_DIR)/include -I/usr/local/include -O0 -g -Wall -Wextra CFLAGS = -fsanitize=address -I $(ROOT_DIR)/include -I/usr/local/include -O0 -g -Wall -Wextra
LDFLAGS = -L/opt/homebrew/opt/llvm/lib -L/usr/local/lib -lglfw -lvulkan -ldl -Xlinker -rpath -Xlinker /usr/local/lib -Xlinker -rpath -Xlinker /opt/homebrew/opt/llvm/lib -Xpreprocessor -fooenmp LDFLAGS = -L/opt/homebrew/opt/llvm/lib -lglfw -lvulkan -ldl -Xlinker -rpath -Xlinker /opt/homebrew/opt/llvm/lib -Xpreprocessor -fooenmp
CC = /opt/homebrew/opt/llvm/bin/clang CC = /opt/homebrew/opt/llvm/bin/clang
GDB = lldb GDB = lldb

4
shader_src/texture.frag
Unescape Escape View File

@ -4,8 +4,8 @@ layout(location = 0) in vec3 fragColor;
layout(location = 1) in vec2 fragTex; layout(location = 1) in vec2 fragTex;
layout(location = 0) out vec4 outColor; layout(location = 0) out vec4 outColor;
layout(set = 1, binding = 0) uniform sampler2D texSampler; layout(set = 1, binding = 0) uniform sampler2D texSamplers[1000];
void main() { void main() {
outColor = texture(texSampler, fragTex); outColor = texture(texSamplers[1], fragTex);
} }

305
src/main.c
Unescape Escape View File

@ -23,22 +23,11 @@
#include <map.h> #include <map.h>
#include <gpu_mem.h> #include <gpu_mem.h>
typedef struct QueueIndicesStruct { typedef struct QueueStruct {
uint32_t graphics_family; VkQueue handle;
uint32_t graphics_index; uint32_t family;
uint32_t index;
uint32_t present_family; } Queue;
uint32_t present_index;
uint32_t transfer_family;
uint32_t transfer_index;
} QueueIndices;
typedef struct QueuesStruct {
VkQueue graphics;
VkQueue present;
VkQueue transfer;
} Queues;
typedef struct SwapchainDetailsStruct { typedef struct SwapchainDetailsStruct {
VkSurfaceCapabilitiesKHR capabilities; VkSurfaceCapabilitiesKHR capabilities;
@ -133,9 +122,11 @@ typedef struct VulkanContextStruct {
VkDebugUtilsMessengerEXT debug_messenger; VkDebugUtilsMessengerEXT debug_messenger;
VkPhysicalDevice physical_device; VkPhysicalDevice physical_device;
QueueIndices queue_indices;
VkDevice device; VkDevice device;
Queues queues;
Queue graphics_queue;
Queue transfer_queue;
Queue present_queue;
// G Buffer // G Buffer
GPUPage* g_buffer_page; GPUPage* g_buffer_page;
@ -451,60 +442,6 @@ VkResult get_best_physical_device(VkInstance instance, VkPhysicalDevice* device)
return VK_SUCCESS; return VK_SUCCESS;
} }
bool check_queue_indices(QueueIndices indices) {
return ((indices.graphics_family != 0xFFFFFFFF)
&& (indices.present_family != 0xFFFFFFFF)
&& (indices.transfer_family != 0xFFFFFFFF));
}
VkResult get_queue_indices(VkPhysicalDevice physical_device, VkSurfaceKHR surface, QueueIndices* indices) {
memset(indices, 0xFF, sizeof(QueueIndices));
uint32_t queue_family_count;
vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, 0);
VkQueueFamilyProperties* queue_families = malloc(sizeof(VkQueueFamilyProperties)*queue_family_count);
vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, queue_families);
for(uint32_t family_idx = 0; family_idx < queue_family_count; family_idx++) {
VkBool32 present_support;
vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, family_idx, surface, &present_support);
for(uint32_t queue_idx = 0; queue_idx < queue_families[family_idx].queueCount; queue_idx++) {
if(((indices->graphics_family == 0xFFFFFFFF)
|| (indices->present_family == 0xFFFFFFFF)
|| (indices->present_family != indices->graphics_family))
&& (queue_families[family_idx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
&& (present_support == VK_TRUE)) {
fprintf(stderr, "Selected %d:%d for graphics and present queues\n", family_idx, queue_idx);
indices->graphics_family = family_idx;
indices->graphics_index = queue_idx;
indices->present_family = family_idx;
indices->present_index = queue_idx;
} else if((indices->graphics_family == 0xFFFFFFFF)
&& (queue_families[family_idx].queueFlags & VK_QUEUE_GRAPHICS_BIT)) {
fprintf(stderr, "Selected %d:%d for graphics queue\n", family_idx, queue_idx);
indices->graphics_family = family_idx;
indices->graphics_index = queue_idx;
} else if((indices->present_family == 0xFFFFFFFF)
&& (present_support == VK_TRUE)) {
fprintf(stderr, "Selected %d:%d for present queue\n", family_idx, queue_idx);
indices->present_family = family_idx;
indices->present_index = queue_idx;
} else if((indices->transfer_family == 0xFFFFFFFF)
&& (queue_families[family_idx].queueFlags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT))) {
fprintf(stderr, "Selected %d:%d for transfer queue\n", family_idx, queue_idx);
indices->transfer_family = family_idx;
indices->transfer_index = queue_idx;
}
}
}
free(queue_families);
return VK_SUCCESS;
}
VkResult create_debug_messenger(VkInstance instance, VkDebugUtilsMessengerEXT* debug_messenger) { VkResult create_debug_messenger(VkInstance instance, VkDebugUtilsMessengerEXT* debug_messenger) {
VkDebugUtilsMessengerCreateInfoEXT messenger_info = { VkDebugUtilsMessengerCreateInfoEXT messenger_info = {
.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
@ -581,42 +518,80 @@ VkResult create_instance(VkInstance* instance) {
return VK_SUCCESS; return VK_SUCCESS;
} }
VkResult create_logical_device(VkPhysicalDevice physical_device, QueueIndices queue_indices, VkDevice* device) { VkResult create_logical_device(VkPhysicalDevice physical_device, VkSurfaceKHR surface, Queue* graphics_queue, Queue* present_queue, Queue* transfer_queue, VkDevice* device) {
uint32_t unique_families[3] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}; if(graphics_queue == NULL || present_queue == NULL || transfer_queue == NULL || device == NULL) {
uint32_t unique_family_queues[3] = {0, 0, 0}; return VK_ERROR_VALIDATION_FAILED_EXT;
uint32_t unique_family_count = 0; }
uint32_t queue_family_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, NULL);
uint32_t queue_family[] = {queue_indices.transfer_family, queue_indices.graphics_family, queue_indices.present_family}; VkQueueFamilyProperties* queue_families = malloc(sizeof(VkQueueFamilyProperties)*queue_family_count);
uint32_t unique_queue_count = 3; vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, queue_families);
if((queue_indices.graphics_family == queue_indices.present_family)
&& (queue_indices.graphics_index == queue_indices.present_index)) { graphics_queue->family = 0xFFFFFFFF;
unique_queue_count = 2; present_queue->family = 0xFFFFFFFF;
for(uint32_t idx = 0; idx < queue_family_count; idx++) {
VkBool32 present_support = VK_FALSE;
vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, idx, surface, &present_support);
VkBool32 graphics_support = (queue_families[idx].queueFlags & VK_QUEUE_GRAPHICS_BIT);
if(graphics_support && present_support) {
graphics_queue->family = idx;
graphics_queue->index = 0;
present_queue->family = idx;
present_queue->index = 0;
break;
} else if (graphics_support && (graphics_queue->family == 0xFFFFFFFF)) {
graphics_queue->family = idx;
graphics_queue->index = 0;
} else if (present_support && (present_queue->family == 0xFFFFFFFF)) {
graphics_queue->family = idx;
present_queue->index = 0;
}
} }
for(uint32_t queue_idx = 0; queue_idx < unique_queue_count; queue_idx++) { transfer_queue->family = 0xFFFFFFFF;
uint32_t idx = 0xFFFFFFFF; for(uint32_t idx = 0; idx < queue_family_count; idx++) {
for(uint32_t check_idx = 0; check_idx < unique_family_count; check_idx++) { VkBool32 graphics_support = (queue_families[idx].queueFlags & VK_QUEUE_GRAPHICS_BIT);
if(queue_family[queue_idx] == unique_families[check_idx]) { VkBool32 compute_support = (queue_families[idx].queueFlags & VK_QUEUE_COMPUTE_BIT);
idx = check_idx; VkBool32 is_graphics_family = (graphics_queue->family == idx);
break; VkBool32 is_present_family = (present_queue->family == idx);
} uint32_t queue_count = queue_families[idx].queueCount;
if(is_graphics_family && (queue_count == 1)) {
continue;
} else if (is_present_family && (queue_count == 1)) {
continue;
} }
if(idx == 0xFFFFFFFF) { if(graphics_support && compute_support) {
unique_families[unique_family_count] = queue_family[queue_idx]; transfer_queue->family = idx;
unique_family_queues[unique_family_count] += 1; if(is_graphics_family || is_present_family) {
unique_family_count += 1; transfer_queue->index = 1;
} else { } else {
unique_family_queues[idx] += 1; transfer_queue->index = 0;
}
} }
} }
if(graphics_queue->family == 0xFFFFFFFF || present_queue->family == 0xFFFFFFFF || transfer_queue->family == 0xFFFFFFFF) {
return VK_ERROR_INITIALIZATION_FAILED;
}
uint32_t family_indices[] = {
transfer_queue->family,
graphics_queue->family,
present_queue->family,
};
VkDeviceQueueCreateInfo queue_create_info[3] = {}; VkDeviceQueueCreateInfo queue_create_info[3] = {};
float default_queue_priority = 1.0f; float default_queue_priority = 1.0f;
for(uint32_t i = 0; i < unique_family_count; i++) { for(uint32_t i = 0; i < 3; i++) {
queue_create_info[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; queue_create_info[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queue_create_info[i].queueFamilyIndex = unique_families[i]; queue_create_info[i].queueFamilyIndex = family_indices[i];
queue_create_info[i].queueCount = unique_family_queues[i]; queue_create_info[i].queueCount = 1;
queue_create_info[i].pQueuePriorities = &default_queue_priority; queue_create_info[i].pQueuePriorities = &default_queue_priority;
} }
@ -638,7 +613,7 @@ VkResult create_logical_device(VkPhysicalDevice physical_device, QueueIndices qu
VkDeviceCreateInfo device_create_info = { VkDeviceCreateInfo device_create_info = {
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pQueueCreateInfos = queue_create_info, .pQueueCreateInfos = queue_create_info,
.queueCreateInfoCount = unique_family_count, .queueCreateInfoCount = 3,
.pEnabledFeatures = &device_features, .pEnabledFeatures = &device_features,
.enabledExtensionCount = device_extension_count, .enabledExtensionCount = device_extension_count,
.ppEnabledExtensionNames = device_extensions, .ppEnabledExtensionNames = device_extensions,
@ -652,6 +627,10 @@ VkResult create_logical_device(VkPhysicalDevice physical_device, QueueIndices qu
return result; return result;
} }
vkGetDeviceQueue(*device, graphics_queue->family, graphics_queue->index, &graphics_queue->handle);
vkGetDeviceQueue(*device, present_queue->family, present_queue->index, &present_queue->handle);
vkGetDeviceQueue(*device, transfer_queue->family, transfer_queue->index, &transfer_queue->handle);
return VK_SUCCESS; return VK_SUCCESS;
} }
@ -717,7 +696,7 @@ VkExtent2D choose_swapchain_extent(SwapchainDetails swapchain_details) {
return swapchain_details.capabilities.currentExtent; return swapchain_details.capabilities.currentExtent;
} }
VkSwapchainKHR create_swapchain(VkDevice device, VkSurfaceFormatKHR format, VkPresentModeKHR present_mode, VkExtent2D extent, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR capabilities, QueueIndices indices, VkSwapchainKHR old_swapchain) { VkSwapchainKHR create_swapchain(VkDevice device, VkSurfaceFormatKHR format, VkPresentModeKHR present_mode, VkExtent2D extent, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR capabilities, uint32_t graphics_family_index, uint32_t present_family_index, VkSwapchainKHR old_swapchain) {
uint32_t image_count = capabilities.minImageCount + 1; uint32_t image_count = capabilities.minImageCount + 1;
uint32_t max_images = capabilities.maxImageCount; uint32_t max_images = capabilities.maxImageCount;
if((max_images > 0) && (image_count > max_images)) { if((max_images > 0) && (image_count > max_images)) {
@ -740,8 +719,8 @@ VkSwapchainKHR create_swapchain(VkDevice device, VkSurfaceFormatKHR format, VkPr
.oldSwapchain = old_swapchain, .oldSwapchain = old_swapchain,
}; };
uint32_t queue_families[2] = {indices.graphics_family, indices.present_index}; uint32_t queue_families[2] = {graphics_family_index, present_family_index};
if(indices.graphics_family != indices.present_family) { if(graphics_family_index != present_family_index) {
swapchain_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT; swapchain_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
swapchain_info.queueFamilyIndexCount = 2; swapchain_info.queueFamilyIndexCount = 2;
swapchain_info.pQueueFamilyIndices = queue_families; swapchain_info.pQueueFamilyIndices = queue_families;
@ -1013,7 +992,7 @@ VkCommandBuffer command_begin_single(VkDevice device, VkCommandPool transfer_poo
return command_buffer; return command_buffer;
} }
VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkCommandPool transfer_pool, VkQueue transfer_queue) { VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkCommandPool transfer_pool, Queue transfer_queue) {
VkResult result = vkEndCommandBuffer(command_buffer); VkResult result = vkEndCommandBuffer(command_buffer);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
vkFreeCommandBuffers(device, transfer_pool, 1, &command_buffer); vkFreeCommandBuffers(device, transfer_pool, 1, &command_buffer);
@ -1026,18 +1005,18 @@ VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkC
.pCommandBuffers = &command_buffer, .pCommandBuffers = &command_buffer,
}; };
result = vkQueueSubmit(transfer_queue, 1, &submit_info, 0); result = vkQueueSubmit(transfer_queue.handle, 1, &submit_info, 0);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
vkFreeCommandBuffers(device, transfer_pool, 1, &command_buffer); vkFreeCommandBuffers(device, transfer_pool, 1, &command_buffer);
return result; return result;
} }
result = vkQueueWaitIdle(transfer_queue); result = vkQueueWaitIdle(transfer_queue.handle);
vkFreeCommandBuffers(device, transfer_pool, 1, &command_buffer); vkFreeCommandBuffers(device, transfer_pool, 1, &command_buffer);
return result; return result;
} }
VkResult command_transition_image_layout(VkDevice device, VkCommandPool transfer_pool, VkQueue transfer_queue, VkImageLayout old_layout, VkImageLayout new_layout, VkImage image, VkAccessFlags src_mask, VkAccessFlags dst_mask, VkPipelineStageFlags source, VkPipelineStageFlags dest, uint32_t source_family, uint32_t dest_family, VkImageAspectFlags aspect_flags) { VkResult command_transition_image_layout(VkDevice device, VkCommandPool transfer_pool, Queue transfer_queue, VkImageLayout old_layout, VkImageLayout new_layout, VkImage image, VkAccessFlags src_mask, VkAccessFlags dst_mask, VkPipelineStageFlags source, VkPipelineStageFlags dest, uint32_t source_family, uint32_t dest_family, VkImageAspectFlags aspect_flags) {
VkCommandBuffer command_buffer = command_begin_single(device, transfer_pool); VkCommandBuffer command_buffer = command_begin_single(device, transfer_pool);
VkImageMemoryBarrier barrier = { VkImageMemoryBarrier barrier = {
@ -1062,7 +1041,7 @@ VkResult command_transition_image_layout(VkDevice device, VkCommandPool transfer
return command_end_single(device, command_buffer, transfer_pool, transfer_queue); return command_end_single(device, command_buffer, transfer_pool, transfer_queue);
} }
VkResult command_copy_buffer_to_image(VkDevice device, VkCommandPool transfer_pool, VkQueue transfer_queue, VkExtent3D image_size, VkBuffer source, VkImage dest) { VkResult command_copy_buffer_to_image(VkDevice device, VkCommandPool transfer_pool, Queue transfer_queue, VkExtent3D image_size, VkBuffer source, VkImage dest) {
VkCommandBuffer command_buffer = command_begin_single(device, transfer_pool); VkCommandBuffer command_buffer = command_begin_single(device, transfer_pool);
VkBufferImageCopy region = { VkBufferImageCopy region = {
@ -1088,7 +1067,7 @@ VkResult command_copy_buffer_to_image(VkDevice device, VkCommandPool transfer_po
return command_end_single(device, command_buffer, transfer_pool, transfer_queue); return command_end_single(device, command_buffer, transfer_pool, transfer_queue);
} }
Texture load_texture(VkDevice device, GPUPage* page, GPUBuffer staging, VkCommandPool transfer_pool, VkQueue transfer_queue, VkCommandPool graphics_pool, VkQueue graphics_queue, VkExtent2D size, VkFormat format, void* image_data, uint32_t transfer_family, uint32_t graphics_family){ Texture load_texture(VkDevice device, GPUPage* page, GPUBuffer staging, VkCommandPool transfer_pool, Queue transfer_queue, VkCommandPool graphics_pool, Queue graphics_queue, VkExtent2D size, VkFormat format, void* image_data){
Texture ret = { Texture ret = {
.image.page = NULL, .image.page = NULL,
.image.memory = NULL, .image.memory = NULL,
@ -1125,7 +1104,7 @@ Texture load_texture(VkDevice device, GPUPage* page, GPUBuffer staging, VkComman
memcpy(staging.page->ptr + staging.memory->offset, image_data, image.memory->size); memcpy(staging.page->ptr + staging.memory->offset, image_data, image.memory->size);
result = command_transition_image_layout(device, transfer_pool, transfer_queue, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, image.handle, 0, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, transfer_family, transfer_family, VK_IMAGE_ASPECT_COLOR_BIT); result = command_transition_image_layout(device, transfer_pool, transfer_queue, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, image.handle, 0, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, transfer_queue.family, transfer_queue.family, VK_IMAGE_ASPECT_COLOR_BIT);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
gpu_image_free(device, image); gpu_image_free(device, image);
return ret; return ret;
@ -1137,13 +1116,13 @@ Texture load_texture(VkDevice device, GPUPage* page, GPUBuffer staging, VkComman
return ret; return ret;
} }
result = command_transition_image_layout(device, transfer_pool, transfer_queue, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, image.handle, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, transfer_family, graphics_family, VK_IMAGE_ASPECT_COLOR_BIT); result = command_transition_image_layout(device, transfer_pool, transfer_queue, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, image.handle, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, transfer_queue.family, graphics_queue.family, VK_IMAGE_ASPECT_COLOR_BIT);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
gpu_image_free(device, image); gpu_image_free(device, image);
return ret; return ret;
} }
result = command_transition_image_layout(device, graphics_pool, graphics_queue, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, image.handle, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, transfer_family, graphics_family, VK_IMAGE_ASPECT_COLOR_BIT); result = command_transition_image_layout(device, graphics_pool, graphics_queue, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, image.handle, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, transfer_queue.family, graphics_queue.family, VK_IMAGE_ASPECT_COLOR_BIT);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
gpu_image_free(device, image); gpu_image_free(device, image);
return ret; return ret;
@ -1293,7 +1272,7 @@ int create_depth_image(VulkanContext* context) {
context->depth_image_view = depth_image_view; context->depth_image_view = depth_image_view;
} }
result = command_transition_image_layout(context->device, context->extra_graphics_pool, context->queues.graphics, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, context->depth_image, 0, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, VK_IMAGE_ASPECT_DEPTH_BIT); result = command_transition_image_layout(context->device, context->extra_graphics_pool, context->graphics_queue, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, context->depth_image, 0, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, VK_IMAGE_ASPECT_DEPTH_BIT);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
fprintf(stderr, "failed to transition depth image\n"); fprintf(stderr, "failed to transition depth image\n");
return 5; return 5;
@ -1332,7 +1311,7 @@ VkResult recreate_swapchain(VulkanContext* context) {
create_depth_image(context); create_depth_image(context);
VkSwapchainKHR swapchain = create_swapchain(context->device, context->swapchain_format, context->swapchain_present_mode, context->swapchain_extent, context->surface, context->swapchain_details.capabilities, context->queue_indices, context->swapchain); VkSwapchainKHR swapchain = create_swapchain(context->device, context->swapchain_format, context->swapchain_present_mode, context->swapchain_extent, context->surface, context->swapchain_details.capabilities, context->graphics_queue.family, context->present_queue.family, context->swapchain);
if(swapchain == VK_NULL_HANDLE) { if(swapchain == VK_NULL_HANDLE) {
context->swapchain = VK_NULL_HANDLE; context->swapchain = VK_NULL_HANDLE;
return VK_ERROR_INITIALIZATION_FAILED; return VK_ERROR_INITIALIZATION_FAILED;
@ -1604,12 +1583,17 @@ Object create_renderable(Mesh* mesh, GraphicsPipeline* pipeline) {
typedef struct TextureSetStruct { typedef struct TextureSetStruct {
uint32_t max_images; uint32_t max_images;
GPUImage** images; Texture* textures;
VkDescriptorSet descriptor; VkDescriptorSet descriptor;
VkDescriptorPool pool; VkDescriptorPool pool;
} TextureSet; } TextureSet;
// TODO
/*VkResult texture_set_add(VkDevice device, GPUPage* page, GPUBuffer staging, VkCommandPool transfer_pool, VkQueue transfer_queue, VkCommandPool graphics_pool, VkQueue graphics_queue, VkExtent2D size, VkFormat format, void* image_data, uint32_t transfer_family, uint32_t graphics_family) {
return VK_SUCCESS;
}*/
VkResult create_texture_set(VkDevice device, VkDescriptorSetLayout layout, uint32_t max_images, TextureSet* out) { VkResult create_texture_set(VkDevice device, VkDescriptorSetLayout layout, uint32_t max_images, TextureSet* out) {
if(out == NULL) { if(out == NULL) {
return VK_ERROR_VALIDATION_FAILED_EXT; return VK_ERROR_VALIDATION_FAILED_EXT;
@ -1617,8 +1601,8 @@ VkResult create_texture_set(VkDevice device, VkDescriptorSetLayout layout, uint3
out->max_images = max_images; out->max_images = max_images;
out->images = malloc(sizeof(GPUImage*)*max_images); out->textures = malloc(sizeof(Texture*)*max_images);
if(out->images == NULL) { if(out->textures == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
} }
@ -1640,7 +1624,7 @@ VkResult create_texture_set(VkDevice device, VkDescriptorSetLayout layout, uint3
VkResult result = vkCreateDescriptorPool(device, &pool_info, 0, &out->pool); VkResult result = vkCreateDescriptorPool(device, &pool_info, 0, &out->pool);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
free(out->images); free(out->textures);
return result; return result;
}; };
@ -1658,7 +1642,7 @@ VkResult create_texture_set(VkDevice device, VkDescriptorSetLayout layout, uint3
result = vkAllocateDescriptorSets(device, &set_info, &out->descriptor); result = vkAllocateDescriptorSets(device, &set_info, &out->descriptor);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
free(out->images); free(out->textures);
vkDestroyDescriptorPool(device, out->pool, 0); vkDestroyDescriptorPool(device, out->pool, 0);
return result; return result;
} }
@ -1955,7 +1939,7 @@ VkResult create_simple_mesh_pipeline(VkDevice device, VkExtent2D extent, VkRende
return create_graphics_pipeline(device, extent, render_pass, offscreen_render_pass, pipeline_info, max_frames_in_flight, out); return create_graphics_pipeline(device, extent, render_pass, offscreen_render_pass, pipeline_info, max_frames_in_flight, out);
} }
VkResult create_texture_mesh_pipeline(VkDevice device, VkPhysicalDeviceMemoryProperties memories, VkExtent2D extent, VkRenderPass render_pass, VkRenderPass offscreen_render_pass, VkDescriptorSetLayout scene_layout, uint32_t max_frames_in_flight, VkCommandPool transfer_pool, VkQueue transfer_queue, VkQueue graphics_queue, VkCommandPool graphics_pool, uint32_t transfer_family, uint32_t graphics_family, GraphicsPipeline* out) { VkResult create_texture_mesh_pipeline(VkDevice device, VkPhysicalDeviceMemoryProperties memories, VkExtent2D extent, VkRenderPass render_pass, VkRenderPass offscreen_render_pass, VkDescriptorSetLayout scene_layout, uint32_t max_frames_in_flight, VkCommandPool transfer_pool, Queue transfer_queue, Queue graphics_queue, VkCommandPool graphics_pool, GraphicsPipeline* out) {
if(out == NULL) { if(out == NULL) {
return VK_ERROR_VALIDATION_FAILED_EXT; return VK_ERROR_VALIDATION_FAILED_EXT;
} }
@ -2094,7 +2078,7 @@ VkResult create_texture_mesh_pipeline(VkDevice device, VkPhysicalDeviceMemoryPro
struct texel GRN = {0, 255, 0, 255}; struct texel GRN = {0, 255, 0, 255};
struct texel BLU = {0, 0, 255, 255}; struct texel BLU = {0, 0, 255, 255};
struct texel texture_data[100] = { struct texel texture_data_0[100] = {
RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, BLK, RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, BLK,
RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, BLK, RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, BLK,
RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, WHT, RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, WHT,
@ -2106,7 +2090,19 @@ VkResult create_texture_mesh_pipeline(VkDevice device, VkPhysicalDeviceMemoryPro
RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, BLK, RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, BLK,
RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, BLK, RED, WHT, GRN, WHT, BLU, WHT, RED, WHT, GRN, BLK,
}; };
(void)texture_data;
struct texel texture_data_1[100] = {
RED, RED, RED, RED, RED, RED, RED, RED, RED, RED,
RED, WHT, WHT, WHT, WHT, WHT, WHT, WHT, WHT, RED,
RED, WHT, GRN, GRN, GRN, GRN, GRN, GRN, WHT, RED,
RED, WHT, GRN, BLU, BLU, BLU, BLU, GRN, WHT, RED,
RED, WHT, GRN, BLU, BLK, BLK, BLU, GRN, WHT, RED,
RED, WHT, GRN, BLU, BLK, BLK, BLU, GRN, WHT, RED,
RED, WHT, GRN, BLU, BLU, BLU, BLU, GRN, WHT, RED,
RED, WHT, GRN, GRN, GRN, GRN, GRN, GRN, WHT, RED,
RED, WHT, WHT, WHT, WHT, WHT, WHT, WHT, WHT, RED,
RED, RED, RED, RED, RED, RED, RED, RED, RED, RED,
};
GPUPage* texture_memory = NULL; GPUPage* texture_memory = NULL;
result = gpu_page_allocate(device, memories, 100000, 0xFFFFFFFF, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, 0, &texture_memory); result = gpu_page_allocate(device, memories, 100000, 0xFFFFFFFF, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, 0, &texture_memory);
@ -2126,13 +2122,19 @@ VkResult create_texture_mesh_pipeline(VkDevice device, VkPhysicalDeviceMemoryPro
return result; return result;
} }
Texture test_texture = load_texture(device, texture_memory, staging, transfer_pool, transfer_queue, graphics_pool, graphics_queue, texture_size, VK_FORMAT_R8G8B8A8_SRGB, texture_data, transfer_family, graphics_family); Texture test_texture_0 = load_texture(device, texture_memory, staging, transfer_pool, transfer_queue, graphics_pool, graphics_queue, texture_size, VK_FORMAT_R8G8B8A8_SRGB, texture_data_0);
Texture test_texture_1 = load_texture(device, texture_memory, staging, transfer_pool, transfer_queue, graphics_pool, graphics_queue, texture_size, VK_FORMAT_R8G8B8A8_SRGB, texture_data_1);
texture_set.images[0] = &test_texture.image; VkDescriptorImageInfo image_info_0 = {
.sampler = test_texture_0.sampler,
.imageView = test_texture_0.view,
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
};
VkDescriptorImageInfo image_info = { VkDescriptorImageInfo image_info_1 = {
.sampler = test_texture.sampler, .sampler = test_texture_1.sampler,
.imageView = test_texture.view, .imageView = test_texture_1.view,
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
}; };
@ -2140,24 +2142,29 @@ VkResult create_texture_mesh_pipeline(VkDevice device, VkPhysicalDeviceMemoryPro
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = texture_set.descriptor, .dstSet = texture_set.descriptor,
.dstBinding = 0, .dstBinding = 0,
.dstArrayElement = 0,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = 1, .descriptorCount = 1,
.pBufferInfo = 0, .pBufferInfo = 0,
.pImageInfo = &image_info,
.pTexelBufferView = 0, .pTexelBufferView = 0,
}; };
descriptor_write.pImageInfo = &image_info_0;
descriptor_write.dstArrayElement = 0;
vkUpdateDescriptorSets(device, 1, &descriptor_write, 0, 0);
descriptor_write.pImageInfo = &image_info_1;
descriptor_write.dstArrayElement = 1;
vkUpdateDescriptorSets(device, 1, &descriptor_write, 0, 0); vkUpdateDescriptorSets(device, 1, &descriptor_write, 0, 0);
for(uint32_t i = 0; i < out->max_frames_in_flight; i++) { for(uint32_t i = 0; i < out->max_frames_in_flight; i++) {
fprintf(stderr, "descriptor[%d]: %p\n", i, out->descriptors[i]);
out->descriptors[i] = texture_set.descriptor; out->descriptors[i] = texture_set.descriptor;
fprintf(stderr, "descriptor[%d]: %p\n", i, out->descriptors[i]);
} }
return VK_SUCCESS; return VK_SUCCESS;
} }
VkResult command_copy_to_buffer(VkDevice device, GPUBuffer staging, VkBuffer destination, void* data, VkDeviceSize size, VkDeviceSize offset, VkCommandPool pool, VkQueue queue) { VkResult command_copy_to_buffer(VkDevice device, GPUBuffer staging, VkBuffer destination, void* data, VkDeviceSize size, VkDeviceSize offset, VkCommandPool pool, Queue queue) {
memcpy(staging.page->ptr + staging.memory->offset, data, size); memcpy(staging.page->ptr + staging.memory->offset, data, size);
VkCommandBuffer command_buffer = command_begin_single(device, pool); VkCommandBuffer command_buffer = command_begin_single(device, pool);
@ -2176,7 +2183,7 @@ VkResult command_copy_to_buffer(VkDevice device, GPUBuffer staging, VkBuffer des
return command_end_single(device, command_buffer, pool, queue); return command_end_single(device, command_buffer, pool, queue);
} }
Mesh* load_mesh_to_buffer(VkDevice device, GPUPage* page, GPUBuffer staging, uint32_t vertex_count, uint32_t vertex_stride, void* vertex_data, uint32_t index_count, uint32_t index_stride, void* index_data, VkCommandPool pool, VkQueue queue) { Mesh* load_mesh_to_buffer(VkDevice device, GPUPage* page, GPUBuffer staging, uint32_t vertex_count, uint32_t vertex_stride, void* vertex_data, uint32_t index_count, uint32_t index_stride, void* index_data, VkCommandPool pool, Queue queue) {
GPUBuffer vertex_buffer = {0}; GPUBuffer vertex_buffer = {0};
GPUBuffer index_buffer = {0}; GPUBuffer index_buffer = {0};
@ -2246,22 +2253,12 @@ VulkanContext* init_vulkan(GLFWwindow* window, uint32_t max_frames_in_flight) {
return 0; return 0;
} }
result = get_queue_indices(context->physical_device, context->surface, &context->queue_indices); result = create_logical_device(context->physical_device, context->surface, &context->graphics_queue, &context->present_queue, &context->transfer_queue, &context->device);
if(result != VK_SUCCESS) {
fprintf(stderr, "failed to get vulkan queue indices\n");
return 0;
}
result = create_logical_device(context->physical_device, context->queue_indices, &context->device);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
fprintf(stderr, "failed to create vulkan logical device\n"); fprintf(stderr, "failed to create vulkan logical device\n");
return 0; return 0;
} }
vkGetDeviceQueue(context->device, context->queue_indices.graphics_family, context->queue_indices.graphics_index, &context->queues.graphics);
vkGetDeviceQueue(context->device, context->queue_indices.present_family, context->queue_indices.present_index, &context->queues.present);
vkGetDeviceQueue(context->device, context->queue_indices.transfer_family, context->queue_indices.transfer_index, &context->queues.transfer);
result = get_swapchain_details(context->physical_device, context->surface, &context->swapchain_details); result = get_swapchain_details(context->physical_device, context->surface, &context->swapchain_details);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
fprintf(stderr, "failed to create vulkan logical device\n"); fprintf(stderr, "failed to create vulkan logical device\n");
@ -2272,7 +2269,7 @@ VulkanContext* init_vulkan(GLFWwindow* window, uint32_t max_frames_in_flight) {
context->swapchain_present_mode = choose_present_mode(context->swapchain_details); context->swapchain_present_mode = choose_present_mode(context->swapchain_details);
context->swapchain_extent = choose_swapchain_extent(context->swapchain_details); context->swapchain_extent = choose_swapchain_extent(context->swapchain_details);
VkSwapchainKHR swapchain = create_swapchain(context->device, context->swapchain_format, context->swapchain_present_mode, context->swapchain_extent, context->surface, context->swapchain_details.capabilities, context->queue_indices, VK_NULL_HANDLE); VkSwapchainKHR swapchain = create_swapchain(context->device, context->swapchain_format, context->swapchain_present_mode, context->swapchain_extent, context->surface, context->swapchain_details.capabilities, context->graphics_queue.family, context->present_queue.family, VK_NULL_HANDLE);
if(swapchain == VK_NULL_HANDLE) { if(swapchain == VK_NULL_HANDLE) {
fprintf(stderr, "failed to create vulkan swapchain\n"); fprintf(stderr, "failed to create vulkan swapchain\n");
return 0; return 0;
@ -2312,7 +2309,7 @@ VulkanContext* init_vulkan(GLFWwindow* window, uint32_t max_frames_in_flight) {
VkCommandPoolCreateInfo extra_pool_info = { VkCommandPoolCreateInfo extra_pool_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.queueFamilyIndex = context->queue_indices.graphics_family, .queueFamilyIndex = context->graphics_queue.family,
.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
}; };
@ -2346,7 +2343,7 @@ VulkanContext* init_vulkan(GLFWwindow* window, uint32_t max_frames_in_flight) {
VkCommandPoolCreateInfo graphics_pool_info = { VkCommandPoolCreateInfo graphics_pool_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
.queueFamilyIndex = context->queue_indices.graphics_family, .queueFamilyIndex = context->graphics_queue.family,
}; };
VkCommandPool graphics_command_pool; VkCommandPool graphics_command_pool;
result = vkCreateCommandPool(context->device, &graphics_pool_info, 0, &graphics_command_pool); result = vkCreateCommandPool(context->device, &graphics_pool_info, 0, &graphics_command_pool);
@ -2360,7 +2357,7 @@ VulkanContext* init_vulkan(GLFWwindow* window, uint32_t max_frames_in_flight) {
VkCommandPoolCreateInfo transfer_pool_info = { VkCommandPoolCreateInfo transfer_pool_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
.queueFamilyIndex = context->queue_indices.transfer_family, .queueFamilyIndex = context->transfer_queue.family,
}; };
VkCommandPool transfer_command_pool; VkCommandPool transfer_command_pool;
result = vkCreateCommandPool(context->device, &transfer_pool_info, 0, &transfer_command_pool); result = vkCreateCommandPool(context->device, &transfer_pool_info, 0, &transfer_command_pool);
@ -2517,7 +2514,7 @@ VulkanContext* init_vulkan(GLFWwindow* window, uint32_t max_frames_in_flight) {
return 0; return 0;
} }
result = command_transition_image_layout(context->device, context->extra_graphics_pool, context->queues.graphics, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, context->g_image_depth.handle, 0, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, VK_IMAGE_ASPECT_DEPTH_BIT); result = command_transition_image_layout(context->device, context->extra_graphics_pool, context->graphics_queue, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, context->g_image_depth.handle, 0, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, VK_IMAGE_ASPECT_DEPTH_BIT);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
fprintf(stderr, "Failed to transition g_image_depth to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL\n"); fprintf(stderr, "Failed to transition g_image_depth to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL\n");
return 0; return 0;
@ -3058,12 +3055,12 @@ VkResult draw_frame(VulkanContext* context, SceneContext* scene, uint32_t pipeli
.pSignalSemaphores = &context->render_finished_semaphores[context->current_frame], .pSignalSemaphores = &context->render_finished_semaphores[context->current_frame],
}; };
result = vkQueueSubmit(context->queues.graphics, 1, &offscreen_submit_info, 0); result = vkQueueSubmit(context->graphics_queue.handle, 1, &offscreen_submit_info, 0);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
return result; return result;
} }
result = vkQueueSubmit(context->queues.graphics, 1, &submit_info, context->in_flight_fences[context->current_frame]); result = vkQueueSubmit(context->graphics_queue.handle, 1, &submit_info, context->in_flight_fences[context->current_frame]);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
return result; return result;
} }
@ -3078,10 +3075,10 @@ VkResult draw_frame(VulkanContext* context, SceneContext* scene, uint32_t pipeli
.pResults = 0, .pResults = 0,
}; };
return vkQueuePresentKHR(context->queues.present, &present_info); return vkQueuePresentKHR(context->present_queue.handle, &present_info);
} }
Object create_simple_mesh_object(PlyMesh ply_mesh, GraphicsPipeline* simple_mesh_pipeline, VkPhysicalDeviceMemoryProperties memories, VkDevice device, VkCommandPool transfer_pool, VkQueue transfer_queue) { Object create_simple_mesh_object(PlyMesh ply_mesh, GraphicsPipeline* simple_mesh_pipeline, VkPhysicalDeviceMemoryProperties memories, VkDevice device, VkCommandPool transfer_pool, Queue transfer_queue) {
Object zero = {}; Object zero = {};
GPUPage* mesh_memory = NULL; GPUPage* mesh_memory = NULL;
@ -3142,7 +3139,7 @@ Object create_simple_mesh_object(PlyMesh ply_mesh, GraphicsPipeline* simple_mesh
return object; return object;
} }
Object create_texture_mesh_object(GraphicsPipeline* texture_mesh_pipeline, VkPhysicalDeviceMemoryProperties memories, VkDevice device, VkCommandPool transfer_pool, VkQueue transfer_queue) { Object create_texture_mesh_object(GraphicsPipeline* texture_mesh_pipeline, VkPhysicalDeviceMemoryProperties memories, VkDevice device, VkCommandPool transfer_pool, Queue transfer_queue) {
Object zero = {}; Object zero = {};
GPUPage* mesh_memory = NULL; GPUPage* mesh_memory = NULL;
@ -3206,19 +3203,19 @@ void main_loop(PlyMesh ply_mesh, GLFWwindow* window, VulkanContext* context) {
return; return;
} }
Object triangle_object = create_simple_mesh_object(ply_mesh, &simple_mesh_pipeline, context->memories, context->device, context->transfer_command_pool, context->queues.transfer); Object triangle_object = create_simple_mesh_object(ply_mesh, &simple_mesh_pipeline, context->memories, context->device, context->transfer_command_pool, context->transfer_queue);
if(triangle_object.attributes.buckets == 0) { if(triangle_object.attributes.buckets == 0) {
fprintf(stderr, "failed to create simple mesh object\n"); fprintf(stderr, "failed to create simple mesh object\n");
return; return;
} }
result = create_texture_mesh_pipeline(context->device, context->memories, context->swapchain_extent, context->render_pass, context->g_renderpass, scene.descriptor_layout, context->max_frames_in_flight, context->transfer_command_pool, context->queues.transfer, context->queues.graphics, context->extra_graphics_pool, context->queue_indices.transfer_family, context->queue_indices.graphics_index, &texture_mesh_pipeline); result = create_texture_mesh_pipeline(context->device, context->memories, context->swapchain_extent, context->render_pass, context->g_renderpass, scene.descriptor_layout, context->max_frames_in_flight, context->transfer_command_pool, context->transfer_queue, context->graphics_queue, context->extra_graphics_pool, &texture_mesh_pipeline);
if(result != VK_SUCCESS) { if(result != VK_SUCCESS) {
fprintf(stderr, "failed to create texture mesh material\n"); fprintf(stderr, "failed to create texture mesh material\n");
return; return;
} }
Object triangle_object_textured = create_texture_mesh_object(&texture_mesh_pipeline, context->memories, context->device, context->transfer_command_pool, context->queues.transfer); Object triangle_object_textured = create_texture_mesh_object(&texture_mesh_pipeline, context->memories, context->device, context->transfer_command_pool, context->transfer_queue);
if(triangle_object_textured.attributes.buckets == 0) { if(triangle_object_textured.attributes.buckets == 0) {
fprintf(stderr, "failed to create texture mesh object\n"); fprintf(stderr, "failed to create texture mesh object\n");
return; return;