vegardbm/vulkan
0
0
Fork 0
Code Issues Pull Requests Releases Activity
Files
1c14a03aba5b97c67ae2b5fa078798f62df5ddee
vulkan/main.c

2472 lines
83 KiB
C
Raw Blame History

#include <stdio.h>
#include <stdlib.h>
#define VK_USE_PLATFORM_WAYLAND_KHR
#define GLFW_INCLUDE_VULKAN
#define GLFW_EXPOSE_NATIVE_WAYLAND
#include <GLFW/glfw3.h>
#include <GLFW/glfw3native.h>
#include <string.h>
#include <limits.h>
#include <time.h>
#include <math.h>
typedef enum {
false = 0,
true = 1,
} bool;
static const uint32_t WIDTH = 800;
static const uint32_t HEIGHT = 600;
#define MAX_FRAMES_IN_FLIGHT 2
static const char* VALIDATION_LAYERS[] = { "VK_LAYER_KHRONOS_validation" };
#define VALIDATION_LAYER_COUNT 1
static const char* DEVICE_EXTENSIONS[] = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
#define DEVICE_EXTENSION_COUNT 1
#ifdef NDEBUG
static const bool enableValidationLayers = false;
#else
static const bool enableValidationLayers = true;
#endif
typedef struct Vec2 {
float x;
float y;
} Vec2;
typedef struct Vec3 {
float x;
float y;
float z;
} Vec3;
typedef struct Vec4 {
float x;
float y;
float z;
float w;
} Vec4;
typedef struct Mat4 {
Vec4 x;
Vec4 y;
Vec4 z;
Vec4 w;
} Mat4;
struct UniformBufferObject {
Mat4 model;
Mat4 view;
Mat4 proj;
} UniformBufferObject;
typedef struct Vertex {
Vec3 pos;
Vec3 color;
Vec2 texCoord;
} Vertex;
struct PPM {
uint32_t width;
uint32_t height;
uint32_t maxVal;
void* pixels;
};
struct VulkanData {
VkInstance instance;
VkDebugUtilsMessengerEXT debugMessenger;
VkPhysicalDevice physicalDevice;
VkDevice device;
VkQueue graphicsQueue;
VkQueue presentQueue;
VkQueue transferQueue;
VkSurfaceKHR surface;
VkSwapchainKHR swapChain;
VkImage swapChainImages[4];
VkFormat swapChainImageFormat;
VkExtent2D swapChainExtent;
VkImageView swapChainImageViews[4];
int imageCount;
VkDescriptorSetLayout descriptorSetLayout;
VkPipelineLayout pipelineLayout;
VkRenderPass renderPass;
VkPipeline graphicsPipeline;
VkFramebuffer swapChainFramebuffers[4];
VkCommandPool commandPool;
VkCommandPool transferCommandPool;
VkCommandBuffer commandBuffers[MAX_FRAMES_IN_FLIGHT];
VkSemaphore imageAvailableSemaphores[MAX_FRAMES_IN_FLIGHT];
VkSemaphore renderFinishedSemaphores[MAX_FRAMES_IN_FLIGHT];
VkFence inFlightFences[MAX_FRAMES_IN_FLIGHT];
uint32_t currentFrame;
bool framebufferResized;
Vertex* vertices;
uint32_t vertexCount;
uint32_t* indices;
uint32_t indexCount;
VkBuffer vertexBuffer;
VkDeviceMemory vertexBufferMemory;
VkBuffer indexBuffer;
VkDeviceMemory indexBufferMemory;
VkBuffer uniformBuffers[MAX_FRAMES_IN_FLIGHT];
VkDeviceMemory uniformBuffersMemory[MAX_FRAMES_IN_FLIGHT];
void* uniformBuffersMapped[MAX_FRAMES_IN_FLIGHT];
VkDescriptorPool descriptorPool;
VkDescriptorSet descriptorSets[MAX_FRAMES_IN_FLIGHT];
uint32_t mipLevels;
VkImage textureImage;
VkDeviceMemory textureImageMemory;
VkImageView textureImageView;
VkSampler textureSampler;
VkImage depthImage;
VkDeviceMemory depthImageMemory;
VkImageView depthImageView;
VkSampleCountFlagBits msaaSamples;
VkImage colorImage;
VkDeviceMemory colorImageMemory;
VkImageView colorImageView;
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
VkPresentModeKHR presentModes[5];
VkSurfaceFormatKHR formats[8];
};
struct Optional {
uint32_t v;
bool is_some;
};
struct QueueFamilyIndices {
struct Optional graphicsFamily;
struct Optional presentFamily;
struct Optional transferFamily;
};
static Vec3 normalize(Vec3 v) {
float size = sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
Vec3 result = {
v.x / size,
v.y / size,
v.z / size,
};
return result;
}
static Vec3 crossProduct(Vec3 a, Vec3 b) {
Vec3 result = {
a.y * b.z - a.z * b.y,
a.z * b.x - a.x * b.z,
a.x * b.y - a.y * b.x,
};
return result;
}
static float dotProduct(Vec3 a, Vec3 b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}
static Mat4 rotate(float angle, Vec3 v) {
float c = cos(angle);
float s = sin(angle);
float x = v.x, y = v.y, z = v.z;
Mat4 result = {
{c + x * x * (1. - c), x * y * (1. - c) - z * s, x * z * (1. - c) + y * s, 0.},
{x * y * (1. - c) + z * s, c + y * y * (1. - c), y * z * (1. - c) - x * s, 0.},
{x * z * (1. - c) - y * s, y * z * (1. - c) + x * s, c + z * z * (1. - c), 0.},
{0., 0., 0., 1.}
};
return result;
}
static Mat4 lookAt(Vec3 eye, Vec3 center, Vec3 up) {
Vec3 f = {
center.x - eye.x,
center.y - eye.y,
center.z - eye.z,
};
f = normalize(f);
up = normalize(up);
Vec3 s = normalize(crossProduct(f, up));
Vec3 u = crossProduct(s, f);
Mat4 mat = {
{s.x, u.x, -f.x, 0.},
{s.y, u.y, -f.y, 0.},
{s.z, u.z, -f.z, 0.},
{-dotProduct(s, eye), -dotProduct(u, eye), dotProduct(f, eye), 1.},
};
return mat;
}
static Mat4 perspective(float angle, float aspectRatio, float near, float far) {
float f = cos(angle / 2.) / sin(angle / 2.);
Mat4 mat = {
{f / aspectRatio, 0., 0., 0.},
{0., f, 0., 0.},
{0., 0., (far + near)/(near - far), -1.},
{0., 0., (2. * far * near)/(near - far), 0.},
};
return mat;
}
static VkVertexInputBindingDescription getBindingDescription() {
VkVertexInputBindingDescription bindingDescription = {
.binding = 0,
.stride = sizeof(Vertex),
.inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
};
return bindingDescription;
}
static void framebufferResizeCallback(GLFWwindow* window, int width, int height) {
printf("INFO: resizing from width: %d, height: %d\n", width, height);
struct VulkanData* app = (struct VulkanData*) glfwGetWindowUserPointer(window);
app->framebufferResized = true;
}
GLFWwindow* initWindow(struct VulkanData* data) {
if (!glfwInit()) {
fprintf(stderr, "ERROR: Failed to initialize window\n");
exit(1);
}
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", NULL, NULL);
if (!window) {
glfwTerminate();
fprintf(stderr, "ERROR: Failed to create window\n");
exit(1);
}
glfwSetWindowUserPointer(window, data);
glfwSetFramebufferSizeCallback(window, framebufferResizeCallback);
return window;
}
static VkImageView createImageView(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags, uint32_t mipLevels, struct VulkanData* data) {
VkImageViewCreateInfo viewInfo = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = image,
.viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = format,
.subresourceRange.aspectMask = aspectFlags,
.subresourceRange.baseMipLevel = 0,
.subresourceRange.levelCount = mipLevels,
.subresourceRange.baseArrayLayer = 0,
.subresourceRange.layerCount = 1,
};
VkImageView imageView;
if (vkCreateImageView(data->device, &viewInfo, NULL, &imageView) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create texture image view\n");
exit(1);
}
return imageView;
}
static VkCommandBuffer beginSingleTimeCommands(bool graphics, struct VulkanData* data) {
VkCommandBufferAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = 1,
};
if (graphics) {
allocInfo.commandPool = data->commandPool;
} else {
allocInfo.commandPool = data->transferCommandPool;
}
VkCommandBuffer commandBuffer;
vkAllocateCommandBuffers(data->device, &allocInfo, &commandBuffer);
VkCommandBufferBeginInfo beginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
};
vkBeginCommandBuffer(commandBuffer, &beginInfo);
return commandBuffer;
}
static void endSingleTimeCommands(VkCommandBuffer commandBuffer, bool graphics, struct VulkanData* data) {
vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.commandBufferCount = 1,
.pCommandBuffers = &commandBuffer,
};
if (graphics) {
vkQueueSubmit(data->graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
vkQueueWaitIdle(data->graphicsQueue);
vkFreeCommandBuffers(data->device, data->commandPool, 1, &commandBuffer);
} else {
vkQueueSubmit(data->transferQueue, 1, &submitInfo, VK_NULL_HANDLE);
vkQueueWaitIdle(data->transferQueue);
vkFreeCommandBuffers(data->device, data->transferCommandPool, 1, &commandBuffer);
}
}
static bool checkValidationLayerSupport() {
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, NULL);
VkLayerProperties availableLayers[layerCount];
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
for (int i = 0; i < VALIDATION_LAYER_COUNT; i++) {
const char* layerName = VALIDATION_LAYERS[i];
uint32_t layerFound = 0;
for (uint32_t j = 0; j < layerCount; j++) {
VkLayerProperties layerProperties = availableLayers[j];
if (strcmp(layerName, layerProperties.layerName) == 0) {
layerFound = 1;
break;
}
}
if (!layerFound) {
return false;
}
}
return true;
}
static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageType,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
void* pUserData) {
if (messageSeverity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT && messageType >= VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) {
printf("validation layer: %s, with data: %p\n", pCallbackData->pMessage, pUserData);
}
return VK_FALSE;
}
static void createInstance(struct VulkanData* data) {
if (enableValidationLayers && !checkValidationLayerSupport()) {
printf("ERROR: Validation layers requested, but not available\n");
exit(1);
}
VkApplicationInfo appInfo = {
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
.pApplicationName = "Hello Triangle",
.applicationVersion = VK_MAKE_VERSION(1, 0, 0),
.pEngineName = "No Engine",
.engineVersion = VK_MAKE_VERSION(1, 0, 0),
.apiVersion = VK_API_VERSION_1_3,
};
uint32_t count = 0;
vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
VkExtensionProperties availableExtensions[count];
vkEnumerateInstanceExtensionProperties(NULL, &count, availableExtensions);
printf("available extensions:\n");
for (uint32_t i = 0; i < count; i++) {
VkExtensionProperties extension = availableExtensions[i];
printf("\t%s\n", extension.extensionName);
}
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
const char* extensions[glfwExtensionCount + 1];
for (uint32_t i = 0; i < glfwExtensionCount; i++) {
extensions[i] = glfwExtensions[i];
}
if (enableValidationLayers) {
extensions[glfwExtensionCount] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
}
uint32_t extensionCount = sizeof(extensions) / sizeof(extensions[0]);
printf("required extensions:\n");
for (uint32_t i = 0; i < extensionCount; i++) {
printf("\t%s\n", extensions[i]);
}
const VkBool32 setting_validate_core = VK_TRUE;
const VkBool32 setting_validate_best_practices = VK_TRUE;
const VkBool32 setting_validate_sync = VK_TRUE;
const VkBool32 setting_thread_safety = VK_TRUE;
const char* setting_debug_action[] = {"VK_DBG_LAYER_ACTION_LOG_MSG"};
const char* setting_report_flags[] = {"info", "warn", "perf", "error", "debug"};
const VkBool32 setting_enable_message_limit = VK_TRUE;
const int32_t setting_duplicate_message_limit = 3;
const VkLayerSettingEXT settings[] = {
{VALIDATION_LAYERS[0], "validate_core", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_validate_core},
{VALIDATION_LAYERS[0], "validate_best_practices", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_validate_best_practices},
{VALIDATION_LAYERS[0], "validate_sync", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_validate_sync},
{VALIDATION_LAYERS[0], "thread_safety", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_thread_safety},
{VALIDATION_LAYERS[0], "debug_action", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, setting_debug_action},
{VALIDATION_LAYERS[0], "report_flags", VK_LAYER_SETTING_TYPE_STRING_EXT, 5, setting_report_flags},
{VALIDATION_LAYERS[0], "enable_message_limit", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_enable_message_limit},
{VALIDATION_LAYERS[0], "duplicate_message_limit", VK_LAYER_SETTING_TYPE_INT32_EXT, 1, &setting_duplicate_message_limit},
};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info = {
VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT,
NULL,
8,
settings,
};
VkInstanceCreateInfo createInfo = {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = &layer_settings_create_info,
.flags = 0,
.pApplicationInfo = &appInfo,
.enabledExtensionCount = extensionCount,
.ppEnabledExtensionNames = extensions,
.enabledLayerCount = 1,
};
if (enableValidationLayers) {
createInfo.enabledLayerCount = VALIDATION_LAYER_COUNT;
createInfo.ppEnabledLayerNames = VALIDATION_LAYERS;
VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo = {
.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
.pfnUserCallback = debugCallback,
};
createInfo.pNext = &debugCreateInfo;
} else {
createInfo.enabledLayerCount = 0;
createInfo.pNext = NULL;
}
VkInstance instance;
if (vkCreateInstance(&createInfo, NULL, &instance) != VK_SUCCESS) {
printf("ERROR: Failed to create instance\n");
exit(1);
}
data->instance = instance;
}
VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
PFN_vkCreateDebugUtilsMessengerEXT func = (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
if (func == NULL) {
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
}
static void setupDebugMessenger(struct VulkanData* data) {
if (!enableValidationLayers) return;
VkDebugUtilsMessengerCreateInfoEXT createInfo = {
.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
.pfnUserCallback = debugCallback,
};
if (CreateDebugUtilsMessengerEXT(data->instance, &createInfo, NULL, &data->debugMessenger) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to set up debug messenger\n");
exit(1);
}
}
static void createSurface(struct VulkanData* data, GLFWwindow* window) {
if (glfwCreateWindowSurface(data->instance, window, NULL, &data->surface) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create window surface\n");
exit(1);
}
}
static void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
PFN_vkDestroyDebugUtilsMessengerEXT func = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
if (func != NULL) {
func(instance, debugMessenger, pAllocator);
}
}
static uint32_t clamp(uint32_t value, uint32_t min, uint32_t max) {
if (value > max) return max;
if (value < min) return min;
return value;
}
static int checkDeviceExtensionSupport(VkPhysicalDevice device) {
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(device, NULL, &extensionCount, NULL);
VkExtensionProperties availableExtensions[extensionCount];
vkEnumerateDeviceExtensionProperties(device, NULL, &extensionCount, availableExtensions);
int requiredExtensionsFound = 0;
for (uint32_t i = 0; i < extensionCount; i++) {
VkExtensionProperties extension = availableExtensions[i];
for (int j = 0; j < DEVICE_EXTENSION_COUNT; j++) {
if (strcmp(extension.extensionName, DEVICE_EXTENSIONS[j]) == 0) {
requiredExtensionsFound++;
break;
}
}
}
return requiredExtensionsFound == DEVICE_EXTENSION_COUNT;
}
static struct SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface) {
struct SwapChainSupportDetails details;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, NULL);
if (formatCount != 0) {
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats);
}
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, NULL);
if (presentModeCount != 0) {
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes);
}
return details;
}
static struct QueueFamilyIndices findQueueFamilies(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface) {
struct QueueFamilyIndices familyIndices = {
.graphicsFamily.v = 0,
.graphicsFamily.is_some = 0,
.presentFamily.v = 0,
.presentFamily.is_some = 0,
.transferFamily.v = 0,
.transferFamily.is_some = 0,
};
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, NULL);
VkQueueFamilyProperties queueFamilies[queueFamilyCount];
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies);
for (uint32_t i = 0; i < queueFamilyCount; i++) {
VkQueueFamilyProperties queueFamily = queueFamilies[i];
if (queueFamily.queueFlags & VK_QUEUE_TRANSFER_BIT
&& !(queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)) {
familyIndices.transferFamily.v = i;
familyIndices.transferFamily.is_some = true;
}
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
familyIndices.graphicsFamily.v = i;
familyIndices.graphicsFamily.is_some = true;
}
VkBool32 presentSupport = 0;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport) {
familyIndices.presentFamily.v = i;
familyIndices.presentFamily.is_some = true;
}
if (familyIndices.presentFamily.is_some && familyIndices.graphicsFamily.is_some && familyIndices.transferFamily.is_some) {
break;
}
}
return familyIndices;
}
static bool isDeviceSuitable(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface) { // One could pick the device based on a score.
struct QueueFamilyIndices familyIndices = findQueueFamilies(physicalDevice, surface);
VkPhysicalDeviceProperties deviceProperties;
vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
printf("GPU: %s\n", deviceProperties.deviceName);
VkPhysicalDeviceFeatures deviceFeatures;
int featureCount = sizeof(deviceFeatures) / sizeof(deviceFeatures.robustBufferAccess);
VkBool32* p = &deviceFeatures.robustBufferAccess;
for (int i = 0; i < featureCount; i++) {
*p = VK_FALSE;
p++;
}
vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);
int extensionsSupported = checkDeviceExtensionSupport(physicalDevice);
int swapChainAdequate = 0;
if (extensionsSupported) {
struct SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice, surface);
swapChainAdequate = swapChainSupport.formats[0].format != 0;
}
return
deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU &&
deviceFeatures.geometryShader && deviceFeatures.samplerAnisotropy &&
swapChainAdequate &&
familyIndices.graphicsFamily.is_some && familyIndices.presentFamily.is_some && familyIndices.transferFamily.is_some;
}
VkSampleCountFlagBits getMaxUseableSampleCount(struct VulkanData* data) {
VkPhysicalDeviceProperties physicalDeviceProperties;
vkGetPhysicalDeviceProperties(data->physicalDevice, &physicalDeviceProperties);
VkSampleCountFlags counts = physicalDeviceProperties.limits.framebufferColorSampleCounts & physicalDeviceProperties.limits.framebufferDepthSampleCounts;
if (counts & VK_SAMPLE_COUNT_64_BIT) {return VK_SAMPLE_COUNT_64_BIT;}
if (counts & VK_SAMPLE_COUNT_32_BIT) {return VK_SAMPLE_COUNT_32_BIT;}
if (counts & VK_SAMPLE_COUNT_16_BIT) {return VK_SAMPLE_COUNT_16_BIT;}
if (counts & VK_SAMPLE_COUNT_8_BIT) {return VK_SAMPLE_COUNT_8_BIT;}
if (counts & VK_SAMPLE_COUNT_4_BIT) {return VK_SAMPLE_COUNT_4_BIT;}
if (counts & VK_SAMPLE_COUNT_2_BIT) {return VK_SAMPLE_COUNT_2_BIT;}
return VK_SAMPLE_COUNT_1_BIT;
}
static void pickPhysicalDevice(struct VulkanData* data) {
data->physicalDevice = VK_NULL_HANDLE;
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(data->instance, &deviceCount, NULL);
if (deviceCount == 0) {
printf("ERROR: Failed to find GPUs with Vulkan support\n");
exit(1);
}
VkPhysicalDevice devices[deviceCount];
vkEnumeratePhysicalDevices(data->instance, &deviceCount, devices);
for (uint32_t i = 0; i < deviceCount; i++) {
VkPhysicalDevice device = devices[i];
if (isDeviceSuitable(device, data->surface)) {
data->physicalDevice = device;
data->msaaSamples = getMaxUseableSampleCount(data);
break;
}
}
if (data->physicalDevice == VK_NULL_HANDLE) {
printf("ERROR: Failed to find a suitable GPU\n");
exit(1);
}
}
static void createLogicalDevice(struct VulkanData* data) {
struct QueueFamilyIndices familyIndices = findQueueFamilies(data->physicalDevice, data->surface);
float queuePriority = 1.0f;
int queueCount = 3;
VkDeviceQueueCreateInfo queueCreateInfos[queueCount];
uint32_t uniqueQueueFamilies[] = {familyIndices.graphicsFamily.v, familyIndices.transferFamily.v, familyIndices.presentFamily.v};
for (int i = 0; i < queueCount; i++) {
uint32_t queueFamily = uniqueQueueFamilies[i];
VkDeviceQueueCreateInfo queueCreateInfo = {
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.queueFamilyIndex = queueFamily,
.queueCount = 1,
.pQueuePriorities = &queuePriority,
};
queueCreateInfos[i] = queueCreateInfo;
}
if (familyIndices.graphicsFamily.v == familyIndices.presentFamily.v) {
queueCount--;
}
for (int i = 0; i < queueCount; i++) {
uint32_t queueFamily = uniqueQueueFamilies[i];
VkDeviceQueueCreateInfo queueCreateInfo = {
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.queueFamilyIndex = queueFamily,
.queueCount = 1,
.pQueuePriorities = &queuePriority,
};
queueCreateInfos[i] = queueCreateInfo;
}
VkPhysicalDeviceFeatures deviceFeatures;
int featureCount = sizeof(deviceFeatures) / 4;
VkBool32* p = &deviceFeatures.robustBufferAccess;
for (int i = 0; i < featureCount; i++) {
*p = VK_FALSE;
p++;
}
deviceFeatures.samplerAnisotropy = VK_TRUE;
deviceFeatures.sampleRateShading = VK_TRUE;
VkDeviceCreateInfo createInfo = {
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pEnabledFeatures = &deviceFeatures,
.enabledExtensionCount = DEVICE_EXTENSION_COUNT,
.queueCreateInfoCount = queueCount,
.pQueueCreateInfos = queueCreateInfos,
.ppEnabledExtensionNames = DEVICE_EXTENSIONS,
};
if (enableValidationLayers) {
createInfo.enabledLayerCount = VALIDATION_LAYER_COUNT;
createInfo.ppEnabledLayerNames = VALIDATION_LAYERS;
} else {
createInfo.enabledLayerCount = 0;
}
if (vkCreateDevice(data->physicalDevice, &createInfo, NULL, &data->device) != VK_SUCCESS) {
printf("ERROR: Failed to create logical device\n");
exit(1);
}
if (!familyIndices.transferFamily.is_some) {
printf("no graphics\n");
}
if (!familyIndices.presentFamily.is_some) {
printf("no present\n");
}
vkGetDeviceQueue(data->device, familyIndices.graphicsFamily.v, 0, &data->graphicsQueue);
vkGetDeviceQueue(data->device, familyIndices.presentFamily.v, 0, &data->presentQueue);
vkGetDeviceQueue(data->device, familyIndices.transferFamily.v, 0, &data->transferQueue);
}
static VkExtent2D chooseSwapExtent(VkSurfaceCapabilitiesKHR* capabilities, GLFWwindow* window) {
if (capabilities->currentExtent.width != UINT_MAX) {
return capabilities->currentExtent;
} else {
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = {
(uint32_t)(width),
(uint32_t)(height)
};
actualExtent.width = clamp(actualExtent.width, capabilities->minImageExtent.width, capabilities->maxImageExtent.width);
actualExtent.height = clamp(actualExtent.height, capabilities->minImageExtent.height, capabilities->maxImageExtent.height);
return actualExtent;
}
}
static VkSurfaceFormatKHR chooseSwapSurfaceFormat(VkSurfaceFormatKHR availableFormats[]) {
for(int i = 0; 1; i++) {
VkSurfaceFormatKHR availableFormat = availableFormats[i];
if (availableFormat.format == VK_FORMAT_UNDEFINED) {
break;
}
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
return availableFormat;
}
}
return availableFormats[0];
}
static VkPresentModeKHR chooseSwapPresentMode(VkPresentModeKHR availablePresentModes[]) {
for(int i = 0; 1; i++) {
if (availablePresentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
return availablePresentModes[i];
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
static void createSwapChain(struct VulkanData* data, GLFWwindow* window) {
struct SwapChainSupportDetails swapChainSupport = querySwapChainSupport(data->physicalDevice, data->surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(&swapChainSupport.capabilities, window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
data->imageCount = imageCount;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) {
imageCount = swapChainSupport.capabilities.maxImageCount;
}
struct QueueFamilyIndices familyIndices = findQueueFamilies(data->physicalDevice, data->surface);
uint32_t queueFamilyIndices[] = {familyIndices.graphicsFamily.v, familyIndices.presentFamily.v};
uint32_t otherFamilyIndices[] = {familyIndices.transferFamily.v, familyIndices.graphicsFamily.v};
VkSwapchainCreateInfoKHR createInfo = {
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
.surface = data->surface,
.minImageCount = imageCount,
.imageFormat = surfaceFormat.format,
.imageColorSpace = surfaceFormat.colorSpace,
.imageExtent = extent,
.imageArrayLayers = 1,
.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
.queueFamilyIndexCount = 2,
.imageSharingMode = VK_SHARING_MODE_CONCURRENT,
.pQueueFamilyIndices = otherFamilyIndices,
.preTransform = swapChainSupport.capabilities.currentTransform,
.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
.presentMode = presentMode,
.clipped = VK_TRUE,
.oldSwapchain = VK_NULL_HANDLE,
};
if (familyIndices.graphicsFamily.v != familyIndices.presentFamily.v) {
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
if (vkCreateSwapchainKHR(data->device, &createInfo, NULL, &data->swapChain) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create swap chain");
}
data->swapChainImageFormat = surfaceFormat.format;
data->swapChainExtent = extent;
vkGetSwapchainImagesKHR(data->device, data->swapChain, &imageCount, NULL);
vkGetSwapchainImagesKHR(data->device, data->swapChain, &imageCount, data->swapChainImages);
}
static void createImageViews(struct VulkanData* data) {
for (int i = 0; i < data->imageCount; i++) {
data->swapChainImageViews[i] = createImageView(data->swapChainImages[i], data->swapChainImageFormat, VK_IMAGE_ASPECT_COLOR_BIT, 1, data);
}
}
static void readFile(const char* fileName, char buffer[], int len) {
FILE* file = fopen(fileName, "r");
if (!file) {
printf("ERROR: File \"%s\" can't be opened \n", fileName);
exit(1);
}
fread(buffer, sizeof(buffer[0]), len, file);
fclose(file);
}
static uint32_t fileSize(const char* fileName) {
FILE* file = fopen(fileName, "r");
if (!file) {
printf("ERROR: File \"%s\" can't be opened \n", fileName);
exit(1);
}
fseek(file, 0L, SEEK_END);
uint32_t size = ftell(file);
printf("INFO: File \"%s\" has size %d\n", fileName, size);
return size;
}
VkFormat findSupportedFormat(const VkFormat* candidates, int candidateCount, VkImageTiling tiling, VkFormatFeatureFlags features, struct VulkanData* data) {
for (int i = 0; i < candidateCount; i++) {
VkFormat format = candidates[i];
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(data->physicalDevice, format, &props);
if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features) {
return format;
} else if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features) {
return format;
}
}
fprintf(stderr, "ERROR: Failed to find supported format\n");
exit(1);
}
VkFormat findDepthFormat(struct VulkanData* data) {
const VkFormat candidates[] = {VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT};
return findSupportedFormat(
candidates,
3,
VK_IMAGE_TILING_OPTIMAL,
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
data
);
}
static VkShaderModule createShaderModule(const char* code, uint32_t size, VkDevice device) {
VkShaderModuleCreateInfo createInfo = {
.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
.codeSize = size,
.pCode = (uint32_t*)code,
};
VkShaderModule shaderModule;
if (vkCreateShaderModule(device, &createInfo, NULL, &shaderModule) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create shader module\n");
}
return shaderModule;
}
static void createGraphicsPipeline(struct VulkanData* data) {
const char* vertFileName = "shaders/vert.spv";
uint32_t vertLen = fileSize(vertFileName);
char vertShaderCode[vertLen];
readFile(vertFileName, vertShaderCode, vertLen);
const char* fragFileName = "shaders/frag.spv";
uint32_t fragLen = fileSize(fragFileName);
char fragShaderCode[fragLen];
readFile(fragFileName, fragShaderCode, fragLen);
VkShaderModule vertShaderModule = createShaderModule(vertShaderCode, vertLen, data->device);
VkShaderModule fragShaderModule = createShaderModule(fragShaderCode, fragLen, data->device);
VkPipelineShaderStageCreateInfo vertShaderStageInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_VERTEX_BIT,
.module = vertShaderModule,
.pName = "main",
};
VkPipelineShaderStageCreateInfo fragShaderStageInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_FRAGMENT_BIT,
.module = fragShaderModule,
.pName = "main",
.pSpecializationInfo = NULL,
};
VkPipelineDepthStencilStateCreateInfo depthStencil = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
.depthTestEnable = VK_TRUE,
.depthWriteEnable = VK_TRUE,
.depthCompareOp = VK_COMPARE_OP_LESS,
.depthBoundsTestEnable = VK_FALSE,
.minDepthBounds = 0., // Optional
.maxDepthBounds = 1., // Optional
.stencilTestEnable = VK_FALSE,
// .front = NULL, // Optional
// .back = NULL, // Optional
};
VkPipelineShaderStageCreateInfo shaderStages[2] = {vertShaderStageInfo, fragShaderStageInfo};
uint32_t dynamicStateCount = 2;
VkDynamicState dynamicStates[] = {
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR
};
VkPipelineDynamicStateCreateInfo dynamicState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
.dynamicStateCount = dynamicStateCount,
.pDynamicStates = dynamicStates,
};
VkVertexInputBindingDescription bindingDescription = getBindingDescription();
VkVertexInputAttributeDescription attributeDescriptions[] = {
{
.binding = 0,
.location = 0,
.format = VK_FORMAT_R32G32B32_SFLOAT,
.offset = offsetof(Vertex, pos),
},
{
.binding = 0,
.location = 1,
.format = VK_FORMAT_R32G32B32_SFLOAT,
.offset = offsetof(Vertex, color),
},
{
.binding = 0,
.location = 2,
.format = VK_FORMAT_R32G32B32_SFLOAT,
.offset = offsetof(Vertex, texCoord),
}
};
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
.vertexBindingDescriptionCount = 1,
.vertexAttributeDescriptionCount = 3,
.pVertexBindingDescriptions = &bindingDescription,
.pVertexAttributeDescriptions = attributeDescriptions,
};
VkPipelineInputAssemblyStateCreateInfo inputAssembly = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
.primitiveRestartEnable = VK_FALSE,
};
VkViewport viewport = {
.x = 0.0f,
.y = 0.0f,
.width = (float) data->swapChainExtent.width,
.height = (float) data->swapChainExtent.height,
.minDepth = 0.0f,
.maxDepth = 1.0f,
};
VkRect2D scissor = {
.offset = {0, 0},
.extent = data->swapChainExtent,
};
VkPipelineViewportStateCreateInfo viewportState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
.viewportCount = 1,
.pViewports = &viewport,
.scissorCount = 1,
.pScissors = &scissor,
};
VkPipelineRasterizationStateCreateInfo rasterizer = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
.depthClampEnable = VK_FALSE,
.rasterizerDiscardEnable = VK_FALSE,
.polygonMode = VK_POLYGON_MODE_FILL,
.lineWidth = 1.0f,
.cullMode = VK_CULL_MODE_BACK_BIT,
.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
.depthBiasEnable = VK_FALSE,
.depthBiasConstantFactor = 0.0f, // Optional
.depthBiasClamp = 0.0f, // Optional
.depthBiasSlopeFactor = 0.0f, // Optional
};
VkPipelineMultisampleStateCreateInfo multisampling = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
.sampleShadingEnable = VK_TRUE,
.rasterizationSamples = data->msaaSamples,
.minSampleShading = .2, // Optional
.pSampleMask = NULL, // Optional
.alphaToCoverageEnable = VK_FALSE, // Optional
.alphaToOneEnable = VK_FALSE, // Optional
};
VkPipelineColorBlendAttachmentState colorBlendAttachment = {
.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
.blendEnable = VK_FALSE,
.srcColorBlendFactor = VK_BLEND_FACTOR_ONE, // Optional
.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO, // Optional
.colorBlendOp = VK_BLEND_OP_ADD, // Optional
.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, // Optional
.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO, // Optional
.alphaBlendOp = VK_BLEND_OP_ADD, // Optional
};
VkPipelineColorBlendStateCreateInfo colorBlending = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
.logicOpEnable = VK_FALSE,
.logicOp = VK_LOGIC_OP_COPY, // Optional
.attachmentCount = 1,
.pAttachments = &colorBlendAttachment,
.blendConstants[0] = 0.0f, // Optional
.blendConstants[1] = 0.0f, // Optional
.blendConstants[2] = 0.0f, // Optional
.blendConstants[3] = 0.0f, // Optional
};
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.setLayoutCount = 1,
.pSetLayouts = &data->descriptorSetLayout,
.pushConstantRangeCount = 0, // Optional
.pPushConstantRanges = NULL, // Optional
};
if (vkCreatePipelineLayout(data->device, &pipelineLayoutInfo, NULL, &data->pipelineLayout) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create pipeline layout\n");
exit(1);
}
VkGraphicsPipelineCreateInfo pipelineInfo = {
.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
.stageCount = 2,
.pStages = shaderStages,
.pVertexInputState = &vertexInputInfo,
.pInputAssemblyState = &inputAssembly,
.pViewportState = &viewportState,
.pRasterizationState = &rasterizer,
.pMultisampleState = &multisampling,
.pDepthStencilState = &depthStencil,
.pColorBlendState = &colorBlending,
.pDynamicState = &dynamicState,
.layout = data->pipelineLayout,
.renderPass = data->renderPass,
.subpass = 0,
.basePipelineHandle = VK_NULL_HANDLE, // Optional
.basePipelineIndex = -1, // Optional
};
if (vkCreateGraphicsPipelines(data->device, VK_NULL_HANDLE, 1, &pipelineInfo, NULL, &data->graphicsPipeline) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create graphics pipeline\n");
exit(1);
}
vkDestroyShaderModule(data->device, fragShaderModule, NULL);
vkDestroyShaderModule(data->device, vertShaderModule, NULL);
}
static void createRenderPass(struct VulkanData* data) {
VkAttachmentDescription colorAttachment = {
.format = data->swapChainImageFormat,
.samples = data->msaaSamples,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
};
VkAttachmentReference colorAttachmentRef = {
.attachment = 0,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
};
VkAttachmentDescription depthAttachment = {
.format = findDepthFormat(data),
.samples = data->msaaSamples,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
};
VkAttachmentReference depthAttachmentRef = {
.attachment = 1,
.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
};
VkAttachmentDescription colorAttachmentResolve = {
.format = data->swapChainImageFormat,
.samples = VK_SAMPLE_COUNT_1_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
};
VkAttachmentReference colorAttachmentResolveRef = {
.attachment = 2,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
};
VkSubpassDescription subpass = {
.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
.colorAttachmentCount = 1,
.pColorAttachments = &colorAttachmentRef,
.pDepthStencilAttachment = &depthAttachmentRef,
.pResolveAttachments = &colorAttachmentResolveRef,
};
VkSubpassDependency dependency = {
.srcSubpass = VK_SUBPASS_EXTERNAL,
.dstSubpass = 0,
.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
};
VkAttachmentDescription attachments[3] = {colorAttachment, depthAttachment, colorAttachmentResolve};
VkRenderPassCreateInfo renderPassInfo = {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
.attachmentCount = 3,
.pAttachments = attachments,
.subpassCount = 1,
.pSubpasses = &subpass,
.dependencyCount = 1,
.pDependencies = &dependency,
};
if (vkCreateRenderPass(data->device, &renderPassInfo, NULL, &data->renderPass) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create render pass!\n");
exit(1);
}
}
static void createFramebuffers(struct VulkanData* data) {
for (int i = 0; i < data->imageCount; i++) {
VkImageView attachments[] = {
data->colorImageView,
data->depthImageView,
data->swapChainImageViews[i],
};
VkFramebufferCreateInfo framebufferInfo = {
.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
.renderPass = data->renderPass,
.attachmentCount = 3,
.pAttachments = attachments,
.width = data->swapChainExtent.width,
.height = data->swapChainExtent.height,
.layers = 1,
};
if (vkCreateFramebuffer(data->device, &framebufferInfo, NULL, &data->swapChainFramebuffers[i]) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create framebuffer\n");
exit(1);
}
}
}
static uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties, struct VulkanData* data) {
VkPhysicalDeviceMemoryProperties memProperties;
vkGetPhysicalDeviceMemoryProperties(data->physicalDevice, &memProperties);
for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
if (typeFilter & (1 << i) && (memProperties.memoryTypes[i].propertyFlags & properties)) {
return i;
}
}
fprintf(stderr, "ERROR: Failed to find suitable memory type\n");
exit(1);
}
bool hasStencilComponent(VkFormat format) {
return format == VK_FORMAT_D32_SFLOAT_S8_UINT || format == VK_FORMAT_D24_UNORM_S8_UINT;
}
static void createImage(uint32_t width, uint32_t height, uint32_t mipLevels, VkSampleCountFlagBits numSamples, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage* image, VkDeviceMemory* imageMemory, struct VulkanData* data) {
VkImageCreateInfo imageInfo = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
.imageType = VK_IMAGE_TYPE_2D,
.extent.width = width,
.extent.height = height,
.extent.depth = 1,
.mipLevels = mipLevels,
.arrayLayers = 1,
.format = format,
.tiling = tiling,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.usage = usage,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.samples = numSamples,
.flags = 0,
};
if (vkCreateImage(data->device, &imageInfo, NULL, image) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create image\n");
exit(1);
}
VkMemoryRequirements memRequirements;
vkGetImageMemoryRequirements(data->device, *image, &memRequirements);
VkMemoryAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.allocationSize = memRequirements.size,
.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties, data),
};
if (vkAllocateMemory(data->device, &allocInfo, NULL, imageMemory) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to allocate image memory\n");
exit(1);
}
vkBindImageMemory(data->device, *image, *imageMemory, 0);
}
static void createCommandPool(struct VulkanData* data) {
struct QueueFamilyIndices queueFamilyIndices = findQueueFamilies(data->physicalDevice, data->surface);
VkCommandPoolCreateInfo poolInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
.queueFamilyIndex = queueFamilyIndices.graphicsFamily.v,
};
VkCommandPoolCreateInfo transferPoolInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
.queueFamilyIndex = queueFamilyIndices.transferFamily.v,
};
if (vkCreateCommandPool(data->device, &poolInfo, NULL, &data->commandPool) != VK_SUCCESS) {
fprintf(stderr, "ERROR: failed to create command pool\n");
exit(1);
}
if (vkCreateCommandPool(data->device, &transferPoolInfo, NULL, &data->transferCommandPool) != VK_SUCCESS) {
fprintf(stderr, "ERROR: failed to create transfer command pool\n");
exit(1);
}
}
static void createCommandBuffers(struct VulkanData* data) {
VkCommandBufferAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.commandPool = data->commandPool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = MAX_FRAMES_IN_FLIGHT,
};
if (vkAllocateCommandBuffers(data->device, &allocInfo, &data->commandBuffers[data->currentFrame]) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to allocate command buffers\n");
exit(1);
}
}
static void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex, struct VulkanData* data) {
VkCommandBufferBeginInfo beginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = 0,
.pInheritanceInfo = NULL,
};
if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to begin recording command buffer\n");
exit(1);
}
VkClearValue clearValues[] = {
{ .color = {{0.0f, 0.0f, 0.0f, 1.0f}}, },
{ .depthStencil = {1., 0}, }
};
VkRenderPassBeginInfo renderPassInfo = {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
.renderPass = data->renderPass,
.framebuffer = data->swapChainFramebuffers[imageIndex],
.renderArea.offset = {0, 0},
.renderArea.extent = data->swapChainExtent,
.clearValueCount = 2,
.pClearValues = clearValues,
};
vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, data->graphicsPipeline);
VkBuffer vertexBuffers[] = {data->vertexBuffer};
VkDeviceSize offsets[] = {0};
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
vkCmdBindIndexBuffer(commandBuffer, data->indexBuffer, 0, VK_INDEX_TYPE_UINT32);
VkViewport viewport = {
.x = 0.0f,
.y = 0.0f,
.width = (float) data->swapChainExtent.width,
.height = (float) data->swapChainExtent.height,
.minDepth = 0.0f,
.maxDepth = 1.0f,
};
vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
VkRect2D scissor = {
.offset = {0, 0},
.extent = data->swapChainExtent,
};
vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, data->pipelineLayout, 0, 1, &data->descriptorSets[data->currentFrame], 0, NULL);
vkCmdDrawIndexed(commandBuffer, data->indexCount, 1, 0, 0, 0);
vkCmdEndRenderPass(commandBuffer);
if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to record command buffer\n");
exit(1);
}
}
static void cleanupSwapChain(struct VulkanData* data) {
vkDestroyImageView(data->device, data->colorImageView, NULL);
vkDestroyImage(data->device, data->colorImage, NULL);
vkFreeMemory(data->device, data->colorImageMemory, NULL);
vkDestroyImageView(data->device, data->depthImageView, NULL);
vkDestroyImage(data->device, data->depthImage, NULL);
vkFreeMemory(data->device, data->depthImageMemory, NULL);
for (int i = 0; i < data->imageCount; i++) {
vkDestroyFramebuffer(data->device, data->swapChainFramebuffers[i], NULL);
}
for (int i = 0; i < data->imageCount; i++) {
vkDestroyImageView(data->device, data->swapChainImageViews[i], NULL);
}
vkDestroySwapchainKHR(data->device, data->swapChain, NULL);
}
static void transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout, uint32_t mipLevels, struct VulkanData* data) {
VkCommandBuffer commandBuffer = beginSingleTimeCommands(true, data);
VkImageMemoryBarrier barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.oldLayout = oldLayout,
.newLayout = newLayout,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = image,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.subresourceRange.baseMipLevel = 0,
.subresourceRange.levelCount = mipLevels,
.subresourceRange.baseArrayLayer = 0,
.subresourceRange.layerCount = 1,
.srcAccessMask = 0,
.dstAccessMask = 0,
};
VkPipelineStageFlags sourceStage;
VkPipelineStageFlags destinationStage;
if (newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
if (hasStencilComponent(format)) {
barrier.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
}
} else {
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
}
if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
} else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
} else if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
barrier.srcAccessMask = 0;
barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
destinationStage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
}
else {
fprintf(stderr, "ERROR: Unsupported layout transition\n");
exit(1);
}
vkCmdPipelineBarrier(
commandBuffer,
sourceStage, destinationStage,
0,
0, NULL,
0, NULL,
1, &barrier
);
endSingleTimeCommands(commandBuffer, true, data);
}
static void createDepthResources(struct VulkanData* data) {
VkFormat depthFormat = findDepthFormat(data);
createImage(
data->swapChainExtent.width,
data->swapChainExtent.height,
1,
data->msaaSamples,
depthFormat,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&data->depthImage,
&data->depthImageMemory,
data
);
data->depthImageView = createImageView(data->depthImage, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT, 1, data);
transitionImageLayout(data->depthImage, depthFormat, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, 1, data);
}
static void createColorResources(struct VulkanData* data) {
VkFormat colorFormat = data->swapChainImageFormat;
createImage(data->swapChainExtent.width, data->swapChainExtent.height, 1, data->msaaSamples, colorFormat, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &data->colorImage, &data->colorImageMemory, data);
data->colorImageView = createImageView(data->colorImage, colorFormat, VK_IMAGE_ASPECT_COLOR_BIT, 1, data);
}
static void recreateSwapChain(struct VulkanData* data, GLFWwindow* window) {
int width = 0, height = 0;
glfwGetFramebufferSize(window, &width, &height);
while (width == 0 || height == 0) {
glfwGetFramebufferSize(window, &width, &height);
glfwWaitEvents();
}
vkDeviceWaitIdle(data->device);
cleanupSwapChain(data);
createSwapChain(data, window);
createImageViews(data);
createColorResources(data);
createDepthResources(data);
createFramebuffers(data);
}
static void updateUniformBuffer(uint32_t currentImage, struct VulkanData* data, struct timespec* start) {
struct timespec end;
if (clock_gettime(CLOCK_MONOTONIC, &end) != 0) {
perror("clock_gettime");
exit(1);
}
double elapsed = (end.tv_sec - start->tv_sec) + (end.tv_nsec - start->tv_nsec) / 1e9;
Vec3 v1 = { 2., 2., 2. };
Vec3 v2 = { 0., 0., 0. };
Vec3 v3 = { 0., 0., 1. };
struct UniformBufferObject ubo = {
.model = rotate(elapsed * M_PI / 2., v3),
.view = lookAt(v1, v2, v3),
.proj = perspective(M_PI / 4., data->swapChainExtent.width / (float) data->swapChainExtent.height, 0.1, 10.),
};
ubo.proj.y.y *= -1.;
memcpy(data->uniformBuffersMapped[currentImage], &ubo, sizeof(ubo));
}
static void drawFrame(struct VulkanData* data, GLFWwindow* window, struct timespec* start) {
vkWaitForFences(data->device, 1, &data->inFlightFences[data->currentFrame], VK_TRUE, UINT64_MAX);
uint32_t imageIndex;
VkResult result = vkAcquireNextImageKHR(data->device, data->swapChain, UINT64_MAX, data->imageAvailableSemaphores[data->currentFrame], VK_NULL_HANDLE, &imageIndex);
if (result == VK_ERROR_OUT_OF_DATE_KHR) {
recreateSwapChain(data, window);
return;
} else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
fprintf(stderr, "ERROR: Failed to acquire swap chain image");
exit(1);
}
vkResetFences(data->device, 1, &data->inFlightFences[data->currentFrame]);
vkResetCommandBuffer(data->commandBuffers[data->currentFrame], 0);
recordCommandBuffer(data->commandBuffers[data->currentFrame], imageIndex, data);
VkSemaphore waitSemaphores[] = {data->imageAvailableSemaphores[data->currentFrame]};
VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
VkSemaphore signalSemaphores[] = {data->renderFinishedSemaphores[data->currentFrame]};
updateUniformBuffer(data->currentFrame, data, start);
VkSubmitInfo submitInfo = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.waitSemaphoreCount = 1,
.pWaitSemaphores = waitSemaphores,
.pWaitDstStageMask = waitStages,
.commandBufferCount = 1,
.pCommandBuffers = &data->commandBuffers[data->currentFrame],
.signalSemaphoreCount = 1,
.pSignalSemaphores = signalSemaphores,
};
if (vkQueueSubmit(data->graphicsQueue, 1, &submitInfo, data->inFlightFences[data->currentFrame]) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to submit draw command buffer\n");
exit(1);
}
VkSwapchainKHR swapChains[] = {data->swapChain};
VkPresentInfoKHR presentInfo = {
.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
.waitSemaphoreCount = 1,
.pWaitSemaphores = signalSemaphores,
.swapchainCount = 1,
.pSwapchains = swapChains,
.pImageIndices = &imageIndex,
.pResults = NULL,
};
result = vkQueuePresentKHR(data->presentQueue, &presentInfo);
if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || data->framebufferResized) {
data->framebufferResized = false;
recreateSwapChain(data, window);
} else if (result != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to present swap chain image");
exit(1);
}
data->currentFrame = (data->currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
}
static void createSyncObjects(struct VulkanData* data) {
VkSemaphoreCreateInfo semaphoreInfo = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
};
VkFenceCreateInfo fenceInfo = {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
.flags = VK_FENCE_CREATE_SIGNALED_BIT,
};
for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
if (vkCreateSemaphore(data->device, &semaphoreInfo, NULL, &data->imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(data->device, &semaphoreInfo, NULL, &data->renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(data->device, &fenceInfo, NULL, &data->inFlightFences[i]) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create semaphores\n");
exit(1);
}
}
}
static void copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height, struct VulkanData* data) {
VkCommandBuffer commandBuffer = beginSingleTimeCommands(false, data);
VkBufferImageCopy region = {
.bufferOffset = 0,
.bufferRowLength = 0,
.bufferImageHeight = 0,
.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.imageSubresource.mipLevel = 0,
.imageSubresource.baseArrayLayer = 0,
.imageSubresource.layerCount = 1,
.imageOffset = {0, 0, 0},
.imageExtent = {width, height, 1},
};
vkCmdCopyBufferToImage(
commandBuffer,
buffer,
image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&region
);
endSingleTimeCommands(commandBuffer, false, data);
}
static void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer* buffer, VkDeviceMemory* bufferMemory, struct VulkanData* data) {
struct QueueFamilyIndices familyIndices = findQueueFamilies(data->physicalDevice, data->surface);
uint32_t otherFamilyIndices[] = {familyIndices.transferFamily.v, familyIndices.graphicsFamily.v};
VkBufferCreateInfo bufferInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.size = size,
.usage = usage,
.sharingMode = VK_SHARING_MODE_CONCURRENT,
.queueFamilyIndexCount = 2,
.pQueueFamilyIndices = otherFamilyIndices,
};
if (vkCreateBuffer(data->device, &bufferInfo, NULL, buffer) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create buffer\n");
exit(1);
}
VkMemoryRequirements memRequirements;
vkGetBufferMemoryRequirements(data->device, *buffer, &memRequirements);
VkMemoryAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.allocationSize = memRequirements.size,
.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties, data),
};
if (vkAllocateMemory(data->device, &allocInfo, NULL, bufferMemory) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to allocate buffer memory\n");
exit(1);
}
vkBindBufferMemory(data->device, *buffer, *bufferMemory, 0);
}
static void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size, struct VulkanData* data) {
VkCommandBuffer commandBuffer = beginSingleTimeCommands(false, data);
VkBufferCopy copyRegion = {
.srcOffset = 0,
.dstOffset = 0,
.size = size,
};
vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);
endSingleTimeCommands(commandBuffer, false, data);
}
static void createIndexBuffer(struct VulkanData* data) {
VkDeviceSize bufferSize = sizeof(data->indices[0]) * data->indexCount;
VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory;
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &stagingBuffer, &stagingBufferMemory, data);
void* indexData;
vkMapMemory(data->device, stagingBufferMemory, 0, bufferSize, 0, &indexData);
memcpy(indexData, data->indices, bufferSize);
vkUnmapMemory(data->device, stagingBufferMemory);
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &data->indexBuffer, &data->indexBufferMemory, data);
copyBuffer(stagingBuffer, data->indexBuffer, bufferSize, data);
vkDestroyBuffer(data->device, stagingBuffer, NULL);
vkFreeMemory(data->device, stagingBufferMemory, NULL);
}
static void createVertexBuffer(struct VulkanData* data) {
VkDeviceSize bufferSize = sizeof(data->vertices[0]) * data->vertexCount;
VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory;
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &stagingBuffer, &stagingBufferMemory, data);
void* vertexData;
vkMapMemory(data->device, stagingBufferMemory, 0, bufferSize, 0, &vertexData);
memcpy(vertexData, data->vertices, bufferSize);
vkUnmapMemory(data->device, stagingBufferMemory);
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &data->vertexBuffer, &data->vertexBufferMemory, data);
copyBuffer(stagingBuffer, data->vertexBuffer, bufferSize, data);
vkDestroyBuffer(data->device, stagingBuffer, NULL);
vkFreeMemory(data->device, stagingBufferMemory, NULL);
}
static void createDescriptorSetLayout(struct VulkanData* data) {
VkDescriptorSetLayoutBinding uboLayoutBinding = {
.binding = 0,
.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
.pImmutableSamplers = NULL,
};
VkDescriptorSetLayoutBinding samplerLayoutBinding = {
.binding = 1,
.descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.pImmutableSamplers = NULL,
.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
};
VkDescriptorSetLayoutBinding bindings[2] = {uboLayoutBinding, samplerLayoutBinding};
VkDescriptorSetLayoutCreateInfo layoutInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.bindingCount = 2,
.pBindings = bindings,
};
if (vkCreateDescriptorSetLayout(data->device, &layoutInfo, NULL, &data->descriptorSetLayout) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create descriptor set layout\n");
exit(1);
}
}
static void createUniformBuffers(struct VulkanData* data) {
VkDeviceSize bufferSize = sizeof(UniformBufferObject);
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
createBuffer(bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &data->uniformBuffers[i], &data->uniformBuffersMemory[i], data);
vkMapMemory(data->device, data->uniformBuffersMemory[i], 0, bufferSize, 0, &data->uniformBuffersMapped[i]);
}
}
static void createDescriptorPool(struct VulkanData* data) {
VkDescriptorPoolSize uboPoolSize = {
.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
.descriptorCount = MAX_FRAMES_IN_FLIGHT,
};
VkDescriptorPoolSize samplerPoolSize = {
.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = MAX_FRAMES_IN_FLIGHT,
};
VkDescriptorPoolSize poolSizes[2] = {uboPoolSize, samplerPoolSize};
VkDescriptorPoolCreateInfo poolInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
.poolSizeCount = 2,
.pPoolSizes = poolSizes,
.maxSets = MAX_FRAMES_IN_FLIGHT,
.flags = 0,
};
if (vkCreateDescriptorPool(data->device, &poolInfo, NULL, &data->descriptorPool) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create descriptor pool\n");
exit(1);
}
}
static void createDescriptorSets(struct VulkanData* data) {
VkDescriptorSetLayout layouts[MAX_FRAMES_IN_FLIGHT];
for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
layouts[i] = data->descriptorSetLayout;
}
VkDescriptorSetAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
.descriptorPool = data->descriptorPool,
.descriptorSetCount = MAX_FRAMES_IN_FLIGHT,
.pSetLayouts = layouts,
};
if (vkAllocateDescriptorSets(data->device, &allocInfo, data->descriptorSets) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to allocate descriptor sets\n");
exit(1);
}
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
VkDescriptorBufferInfo bufferInfo = {
.buffer = data->uniformBuffers[i],
.offset = 0,
.range = sizeof(UniformBufferObject),
};
VkDescriptorImageInfo imageInfo = {
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.imageView = data->textureImageView,
.sampler = data->textureSampler,
};
VkWriteDescriptorSet descriptorWrites[2] = {
{
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = data->descriptorSets[i],
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
.descriptorCount = 1,
.pBufferInfo = &bufferInfo,
.pImageInfo = NULL,
.pTexelBufferView = NULL,
},
{
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = data->descriptorSets[i],
.dstBinding = 1,
.dstArrayElement = 0,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = 1,
.pBufferInfo = NULL,
.pImageInfo = &imageInfo,
.pTexelBufferView = NULL,
}
};
vkUpdateDescriptorSets(data->device, 2, descriptorWrites, 0, NULL);
}
}
// Because of the format support and alpha of 1 is added
static struct PPM readPPM(char* fileName) {
FILE* file = fopen(fileName, "r");
char header[2];
fread(header, sizeof(header[0]), 2, file);
if (header[0] != 'P' || header[1] != '6') {
fprintf(stderr, "ERROR: Unrecognized file format\n");
exit(1);
}
if (fseek(file, 1, SEEK_CUR)) {
fprintf(stderr, "ERROR: Failed to read image: \"%s\"\n", fileName);
exit(1);
}
int len = 0;
char c = '0';
while (true) {
if (fread(&c, 1, 1, file) != 1) {
fprintf(stderr, "ERROR: Failed to read width of image: \"%s\" with char: %c\n", fileName, c);
exit(1);
}
if (c < '0' || c > '9') {
break;
}
len++;
}
fseek(file, -len - 1, SEEK_CUR);
char widthStr[len + 1];
fread(widthStr, sizeof(widthStr[0]), len, file);
widthStr[len] = 0;
int width = atoi(widthStr);
fseek(file, 1, SEEK_CUR);
len = 0;
c = '0';
while (true) {
if (fread(&c, 1, 1, file) != 1) {
fprintf(stderr, "ERROR: Failed to read height of image: \"%s\"\n", fileName);
exit(1);
}
if (c < '0' || c > '9') {
break;
}
len++;
}
fseek(file, -len - 1, SEEK_CUR);
char heightStr[len + 1];
fread(heightStr, sizeof(heightStr[0]), len, file);
heightStr[len] = 0;
int height = atoi(heightStr);
fseek(file, 1, SEEK_CUR);
len = 0;
c = '0';
while (true) {
if (fread(&c, 1, 1, file) != 1) {
fprintf(stderr, "ERROR: Failed to read maximum value for pixels in image: \"%s\"\n", fileName);
exit(1);
}
if (c < '0' || c > '9') {
break;
}
len++;
}
fseek(file, -len - 1, SEEK_CUR);
char maxValStr[len + 1];
fread(maxValStr, sizeof(maxValStr[0]), len, file);
maxValStr[len] = 0;
int maxVal = atoi(maxValStr);
printf("INFO: Image \"%s\" has a width and height of (%d, %d) and maximum value for pixels of %d\n", fileName, width, height, maxVal);
fseek(file, 1, SEEK_CUR);
int pixelCount = width * height;
struct PPM ppm = {
.width = width,
.height = height,
.maxVal = maxVal,
.pixels = NULL,
};
if (maxVal <= UCHAR_MAX) {
uint8_t* pixels = malloc(pixelCount * 4);
uint8_t* pixel_p = pixels;
for (int i = 0; i < pixelCount; i++) {
fread(pixel_p, sizeof(uint8_t), 3, file);
pixel_p += 3;
*pixel_p = UCHAR_MAX;
pixel_p++;
}
ppm.pixels = pixels;
} else if (maxVal <= USHRT_MAX) {
uint16_t* pixels = malloc(pixelCount * sizeof(uint16_t) * 4);
uint16_t* pixel_p = pixels;
for (int i = 0; i < pixelCount; i++) {
fread(pixel_p, sizeof(uint16_t), 3, file);
pixel_p += 3;
*pixel_p = USHRT_MAX;
pixel_p++;
}
ppm.pixels = pixels;
} else {
fprintf(stderr, "ERROR: Specified maximum value for pixels is too large\n");
exit(1);
}
return ppm;
}
static void generateMipmaps(VkImage image, VkFormat imageFormat, int32_t texWidth, int32_t texHeight, uint32_t mipLevels, struct VulkanData* data) {
VkFormatProperties formatProperties;
vkGetPhysicalDeviceFormatProperties(data->physicalDevice, imageFormat, &formatProperties);
if (!(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) {
fprintf(stderr, "ERROR: Texture image format does not support linear blitting\n");
exit(1);
}
VkCommandBuffer commandBuffer = beginSingleTimeCommands(true, data);
VkImageMemoryBarrier barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.image = image,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.subresourceRange.baseArrayLayer = 0,
.subresourceRange.layerCount = 1,
.subresourceRange.levelCount = 1,
};
int32_t mipWidth = texWidth;
int32_t mipHeight = texHeight;
for (uint32_t i = 1; i < mipLevels; i++) {
barrier.subresourceRange.baseMipLevel = i - 1;
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
vkCmdPipelineBarrier(commandBuffer,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
0, NULL,
0, NULL,
1, &barrier
);
VkImageBlit blit = {
.srcOffsets[0] = {0, 0, 0},
.srcOffsets[1] = {mipWidth, mipHeight, 1},
.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.srcSubresource.mipLevel = i - 1,
.srcSubresource.baseArrayLayer = 0,
.srcSubresource.layerCount = 1,
.dstOffsets[0] = {0, 0, 0},
.dstOffsets[1] = { mipWidth > 1 ? mipWidth / 2 : 1, mipHeight > 1 ? mipHeight / 2 : 1, 1 },
.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.dstSubresource.mipLevel = i,
.dstSubresource.baseArrayLayer = 0,
.dstSubresource.layerCount = 1,
};
vkCmdBlitImage(commandBuffer,
image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1, &blit,
VK_FILTER_LINEAR
);
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
vkCmdPipelineBarrier(commandBuffer,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0,
0, NULL,
0, NULL,
1, &barrier
);
if (mipWidth > 1) {mipWidth /= 2;}
if (mipHeight > 1) {mipHeight /= 2;}
}
barrier.subresourceRange.baseMipLevel = mipLevels - 1;
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
vkCmdPipelineBarrier(commandBuffer,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0,
0, NULL,
0, NULL,
1, &barrier
);
endSingleTimeCommands(commandBuffer, true, data);
}
static void createTextureImage(struct VulkanData* data) {
struct PPM ppm = readPPM("images/viking_room.ppm");
int nSize = 1;
VkFormat format = VK_FORMAT_R8G8B8A8_SRGB;
if (ppm.maxVal > 255) {
nSize = 2;
format = VK_FORMAT_R16G16B16_UINT;
}
VkDeviceSize imageSize = ppm.width * ppm.height * nSize * 4;
data->mipLevels = floor(log2(fmax(ppm.width, ppm.height))) + 1;
printf("mipLevels: %d\n", data->mipLevels);
VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory;
createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &stagingBuffer, &stagingBufferMemory, data);
void* imageData;
vkMapMemory(data->device, stagingBufferMemory, 0, imageSize, 0, &imageData);
memcpy(imageData, ppm.pixels, imageSize);
vkUnmapMemory(data->device, stagingBufferMemory);
free(ppm.pixels);
createImage(ppm.width, ppm.height, data->mipLevels, VK_SAMPLE_COUNT_1_BIT, format, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &data->textureImage, &data->textureImageMemory, data),
transitionImageLayout(data->textureImage, format, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, data->mipLevels, data);
copyBufferToImage(stagingBuffer, data->textureImage, ppm.width, ppm.height, data);
// transitioned to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL while generating mipmaps
generateMipmaps(data->textureImage, format, ppm.width, ppm.height, data->mipLevels, data);
vkDestroyBuffer(data->device, stagingBuffer, NULL);
vkFreeMemory(data->device, stagingBufferMemory, NULL);
}
static void createTextureImageView(struct VulkanData* data) {
data->textureImageView = createImageView(data->textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_ASPECT_COLOR_BIT, data->mipLevels, data);
}
static void createTextureSampler(struct VulkanData* data) {
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(data->physicalDevice, &properties);
VkSamplerCreateInfo samplerInfo = {
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
.magFilter = VK_FILTER_LINEAR,
.minFilter = VK_FILTER_LINEAR,
.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.anisotropyEnable = VK_TRUE,
.maxAnisotropy = properties.limits.maxSamplerAnisotropy, // set to 1 to disable
.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
.unnormalizedCoordinates = VK_FALSE,
.compareEnable = VK_FALSE,
.compareOp = VK_COMPARE_OP_ALWAYS,
.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
.minLod = 0.,
.maxLod = VK_LOD_CLAMP_NONE,
.mipLodBias = 0.,
};
if (vkCreateSampler(data->device, &samplerInfo, NULL, &data->textureSampler) != VK_SUCCESS) {
fprintf(stderr, "ERROR: Failed to create texture sampler\n");
exit(1);
}
}
float parseFloat(char data[], char numberBuf[], int* i) {
int j = 0;
char c = data[*i + j];
while (c != ' ' && c != '\n') {
if ((c >= '0' && c <= '9') || c == '.' || c == '-') {
numberBuf[j] = c;
} else {
printf("ERROR: sheesh at char: %c\n", c);
exit(1);
}
j++;
c = data[*i + j];
}
numberBuf[j] = 0;
*i += j + 1;
return atof(numberBuf);
}
struct ObjModel {
void* p;
int vertexCount;
int normalCount;
uint32_t faceCount;
int faceSplitCount;
Vec3* vertexPos;
Vec2* texPos;
Vec3* normalVectors;
int* faces;
int* faceSplits;
};
static struct ObjModel readObjFile(const char* fileName) {
FILE* file = fopen(fileName, "r");
int objFileSize = fileSize(fileName);
char* data = malloc(objFileSize);
fread(data, sizeof(char), objFileSize, file);
int lines = 0;
for (int i = 0; i < objFileSize; i++) {
if (data[i] == '\n') {
lines++;
}
}
int lengthOfLines[lines];
int currentLine = 0;
int lineLenCount = 0;
for (int i = 0; i < objFileSize; i++) {
lineLenCount++;
if (data[i] == '\n') {
lengthOfLines[currentLine] = lineLenCount - 1;
lineLenCount = 0;
currentLine++;
}
}
int vertexCount = 0;
int curveCount = 0;
int normalCount = 0;
int textureCount = 0;
int faceCount = 0;
int faceSplitCount = 0;
currentLine = 0;
for (int i = 0; currentLine < lines; i++) {
if (data[i] == 'v') {
switch(data[i + 1]) {
case ' ':
vertexCount++;
break;
case 'p':
curveCount++;
break;
case 'n':
normalCount++;
break;
case 't':
textureCount++;
break;
default:
printf("ERROR: Invalid char\n");
exit(1);
}
} else if (data[i] == 'f') {
faceCount++;
} else if (data[i] == 's') {
faceSplitCount++;
}
i += lengthOfLines[currentLine];
currentLine++;
}
printf("vertices: %d, curvePoints: %d, normalVectors: %d, textureVertices: %d, faces: %d\n", vertexCount, curveCount, normalCount, textureCount, faceCount);
int vertexSize = sizeof(Vec3) * vertexCount;
int textureSize = sizeof(Vec2) * textureCount;
int normalSize = sizeof(Vec3) * normalCount;
int faceSize = sizeof(int) * 9 * faceCount;
int faceSplitSize = sizeof(int) * faceSplitCount;
char* p = malloc(vertexSize + textureSize + normalSize + faceSize + faceSplitSize);
Vec3* vertexPos = (Vec3*) p;
Vec2* texPos = (Vec2*) (p + vertexSize);
Vec3* normalVectors = (Vec3*) (p + vertexSize + textureSize);
int* faces = (int*) (p + vertexSize + textureSize + normalSize);
int* faceSplits = (int*) (p + vertexSize + textureSize + normalSize + faceSize);
int vertexIndex = 0;
int textureIndex = 0;
int normalIndex = 0;
int faceIndex = 0;
int faceSplitIndex = 0;
char numberBuf[16];
currentLine = 0;
for (int i = 0; i < objFileSize; i++) {
if (data[i] == 'v') {
if (data[i + 1] == ' ') {
i += 2;
Vec3 pos = {
parseFloat(data, numberBuf, &i),
parseFloat(data, numberBuf, &i),
parseFloat(data, numberBuf, &i),
};
vertexPos[vertexIndex] = pos;
vertexIndex++;
i--;
} else if (data[i + 1] == 'p') {
} else if(data[i + 1] == 'n') {
i += 3;
Vec3 pos = {
parseFloat(data, numberBuf, &i),
parseFloat(data, numberBuf, &i),
parseFloat(data, numberBuf, &i),
};
normalVectors[normalIndex] = pos;
normalIndex++;
i--;
} else if (data[i + 1] == 't') {
i += 3;
Vec2 pos = {
parseFloat(data, numberBuf, &i),
parseFloat(data, numberBuf, &i),
};
texPos[textureIndex] = pos;
textureIndex++;
i--;
} else {
printf("sheesh\n");
exit(1);
}
} else if (data[i] == 'f') {
i += 2;
int numLen = 0;
for (int j = 0; j < 9; j++) {
while (data[i + numLen] != '/' && data[i + numLen] != ' ' && data[i + numLen] != '\n') {
numLen++;
}
for (int k = 0; k < numLen; k++) {
numberBuf[k] = data[i + k];
}
numberBuf[numLen] = 0;
faces[faceIndex * 9 + j] = atoi(numberBuf);
i += numLen + 1;
numLen = 0;
}
i--;
faceIndex++;
} else if (data[i] == 's') {
faceSplits[faceSplitIndex] = faceIndex;
i += lengthOfLines[currentLine];
} else {
i += lengthOfLines[currentLine];
}
currentLine++;
}
printf("last vert pos: (%f, %f, %f)\n", vertexPos[vertexCount - 1].x, vertexPos[vertexCount - 1].y, vertexPos[vertexCount - 1].z);
printf("last texture pos: (%f, %f)\n", texPos[textureCount - 1].x, texPos[textureCount - 1].y);
printf("last normal pos: (%f, %f, %f)\n", normalVectors[normalCount - 1].x, normalVectors[normalCount - 1].y, normalVectors[normalCount - 1].z);
printf("last face: %d, %d\n", faces[(faceCount - 1) * 9], faces[(faceCount - 1) * 9 + 8]);
printf("face split: %d\n", faceSplits[0]);
free(data);
struct ObjModel model = {
p,
vertexCount,
normalCount,
faceCount,
faceSplitCount,
vertexPos,
texPos,
normalVectors,
faces,
faceSplits,
};
return model;
}
bool isVertexEqual(Vertex* a, Vertex* b) {
return
a->pos.x == b->pos.x
&& a->pos.y == b->pos.y
&& a->pos.z == b->pos.z
&& a->texCoord.x == b->texCoord.x
&& a->texCoord.y == b->texCoord.y;
}
static void loadModel(struct VulkanData* data) {
struct ObjModel model = readObjFile("models/viking_room.obj");
data->indexCount = model.faceCount * 3;
void* p = malloc(data->indexCount * (sizeof(Vertex) + sizeof(uint32_t)));
data->vertices = p;
data->indices = (uint32_t*)((char*)p + sizeof(Vertex) * data->indexCount);
int uniqueVertexCount = 0;
printf("Vertices allocated %ld bytes\n", sizeof(Vertex) * data->indexCount);
printf("Index count: %d\n", data->indexCount);
for (uint32_t i = 0; i < data->indexCount; i++) {
uint32_t* face = ((uint32_t*) model.faces + i * 3);
Vertex vertex = {
.pos = model.vertexPos[*(face) - 1],
.texCoord = model.texPos[*(face + 1) - 1],
.color = {1., 1., 1.},
};
vertex.texCoord.y = 1. - vertex.texCoord.y;
bool seen = false;
for (int j = 0; j < uniqueVertexCount; j++) {
if (isVertexEqual(&vertex, &data->vertices[j])) {
data->indices[i] = j;
seen = true;
break;
}
}
if (seen) {
continue;
}
data->vertices[uniqueVertexCount] = vertex;
data->indices[i] = uniqueVertexCount;
uniqueVertexCount++;
}
// Realign data such that vertices are right next to indices
data->vertexCount = uniqueVertexCount;
memmove((Vertex*)p + data->vertexCount, data->indices, sizeof(uint32_t) * data->indexCount);
p = realloc(p, sizeof(Vertex) * data->vertexCount + sizeof(uint32_t) * data->indexCount);
data->vertices = p;
data->indices = (uint32_t*)((Vertex*)p + data->vertexCount);
printf("Vertices are now using %ld bytes\n", sizeof(Vertex) * data->vertexCount);
free(model.p);
printf("Unique vertices: %d\n", data->vertexCount);
}
static void initVulkan(GLFWwindow* window, struct VulkanData* data) {
data->currentFrame = 0;
data->framebufferResized = false;
data->msaaSamples = VK_SAMPLE_COUNT_1_BIT;
createInstance(data);
setupDebugMessenger(data);
createSurface(data, window);
pickPhysicalDevice(data);
createLogicalDevice(data);
createSwapChain(data, window);
createImageViews(data);
createRenderPass(data);
createDescriptorSetLayout(data);
createGraphicsPipeline(data);
createCommandPool(data);
createColorResources(data);
createDepthResources(data);
createFramebuffers(data);
createTextureImage(data);
createTextureImageView(data);
createTextureSampler(data);
loadModel(data);
createVertexBuffer(data);
createIndexBuffer(data);
createUniformBuffers(data);
createDescriptorPool(data);
createDescriptorSets(data);
createCommandBuffers(data);
createSyncObjects(data);
}
static void mainLoop(GLFWwindow* window, struct VulkanData* data, struct timespec* start) {
struct timespec frameTimeStart, frameTimeEnd;
int count = 100;
double elapsed[count];
int i = 0;
while (!glfwWindowShouldClose(window)) {
if (clock_gettime(CLOCK_MONOTONIC, &frameTimeStart) != 0) {
perror("clock_gettime");
exit(1);
}
glfwSwapBuffers(window);
glfwPollEvents();
drawFrame(data, window, start);
int state = glfwGetKey(window, GLFW_KEY_Q);
if (state == GLFW_PRESS) {
break;
}
if (clock_gettime(CLOCK_MONOTONIC, &frameTimeEnd) != 0) {
perror("clock_gettime");
exit(1);
}
elapsed[i] = (frameTimeEnd.tv_sec - frameTimeStart.tv_sec) + (frameTimeEnd.tv_nsec - frameTimeStart.tv_nsec) / 1e6;
i++;
i %= count;
if (i == 0) {
double worst = elapsed[0];
for(int j = 1; j < count; j++) {
worst = fmax(worst, elapsed[j]);
}
printf("INFO: worst of %d: %f ms\n", count, worst);
}
}
vkDeviceWaitIdle(data->device);
}
static void cleanup(GLFWwindow* window, struct VulkanData* data) {
cleanupSwapChain(data);
// Only one allocation for both vertices and indices
free(data->vertices);
vkDestroySampler(data->device, data->textureSampler, NULL);
vkDestroyImageView(data->device, data->textureImageView, NULL);
vkDestroyImage(data->device, data->textureImage, NULL);
vkFreeMemory(data->device, data->textureImageMemory, NULL);
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
vkDestroyBuffer(data->device, data->uniformBuffers[i], NULL);
vkFreeMemory(data->device, data->uniformBuffersMemory[i], NULL);
}
vkDestroyDescriptorPool(data->device, data->descriptorPool, NULL);
vkDestroyDescriptorSetLayout(data->device, data->descriptorSetLayout, NULL);
vkDestroyBuffer(data->device, data->vertexBuffer, NULL);
vkFreeMemory(data->device, data->vertexBufferMemory, NULL);
vkDestroyBuffer(data->device, data->indexBuffer, NULL);
vkFreeMemory(data->device, data->indexBufferMemory, NULL);
vkDestroyPipeline(data->device, data->graphicsPipeline, NULL);
vkDestroyPipelineLayout(data->device, data->pipelineLayout, NULL);
vkDestroyRenderPass(data->device, data->renderPass, NULL);
for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
vkDestroySemaphore(data->device, data->imageAvailableSemaphores[i], NULL);
vkDestroySemaphore(data->device, data->renderFinishedSemaphores[i], NULL);
vkDestroyFence(data->device, data->inFlightFences[i], NULL);
}
vkDestroyCommandPool(data->device, data->commandPool, NULL);
vkDestroyCommandPool(data->device, data->transferCommandPool, NULL);
vkDestroyDevice(data->device, NULL);
if (enableValidationLayers) {
DestroyDebugUtilsMessengerEXT(data->instance, data->debugMessenger, NULL);
}
vkDestroySurfaceKHR(data->instance, data->surface, NULL);
vkDestroyInstance(data->instance, NULL);
glfwDestroyWindow(window);
glfwTerminate();
}
static void run() {
struct VulkanData data;
printf("INFO: Size of data struct: %ld bytes\n", sizeof(data));
GLFWwindow* window = initWindow(&data);
initVulkan(window, &data);
struct timespec start;
if (clock_gettime(CLOCK_MONOTONIC, &start) != 0) {
perror("clock_gettime");
exit(1);
}
mainLoop(window, &data, &start);
cleanup(window, &data);
}
int main() {
run();
}
Reference in New Issue View Git Blame Copy Permalink