first commit

rendering_api/vulkan/src/output_device/vulkan_output_device.cpp

@@ -0,0 +1,87 @@
+#include <vulkan/vulkan.h>
+#include "presentation_queue/vulkan_queue_families.h"
+#include "presentation_queue/vulkan_swapchain.h"
+#include "vulkan_output_devices.h"
+#include <instance/vulkan_instance.h>
+#include "set"
+
+GN_EXPORT gnReturnCode gnRegisterOutputDeviceFn(gnOutputDevice* outputDevice, const gnInstance& instance, const gnPhysicalOutputDevice& physicalDevice) {
+    if (outputDevice->outputDevice == nullptr) outputDevice->outputDevice = new gnPlatformOutputDevice();
+
+    QueueFamilyIndices indices = findQueueFamilies(instance.instance->window_surface, physicalDevice.physicalOutputDevice->device);
+
+    std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
+    std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value(), indices.presentFamily.value()};
+
+    float queuePriority = 1.0f;
+    for (uint32_t queueFamily : uniqueQueueFamilies) {
+        VkDeviceQueueCreateInfo queueCreateInfo{};
+        queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+        queueCreateInfo.queueFamilyIndex = queueFamily;
+        queueCreateInfo.queueCount = 1;
+        queueCreateInfo.pQueuePriorities = &queuePriority;
+        queueCreateInfos.push_back(queueCreateInfo);
+    }
+
+    VkPhysicalDeviceFeatures deviceFeatures{};
+    deviceFeatures.samplerAnisotropy = VK_TRUE;
+
+    VkDeviceCreateInfo createInfo{};
+    createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+    createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
+    createInfo.pQueueCreateInfos = queueCreateInfos.data();
+
+
+    createInfo.pEnabledFeatures = &deviceFeatures;
+
+    createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
+    createInfo.ppEnabledExtensionNames = deviceExtensions.data();
+
+    if (instance.debugger) {
+        auto validation_layers = instance.debugger->debug_layers;
+
+        gnList<const char*> validation_layers_c = gnCreateList<const char*>();
+        for (int i = 0; i < gnListLength(validation_layers); i++)
+            gnListAdd(validation_layers_c, gnToCString(validation_layers[i]));
+
+        createInfo.enabledLayerCount = static_cast<uint32_t>(gnListLength(validation_layers_c));
+        createInfo.ppEnabledLayerNames = gnListData(validation_layers_c);
+    } else {
+        createInfo.enabledLayerCount = 0;
+    }
+
+    if (vkCreateDevice(physicalDevice.physicalOutputDevice->device, &createInfo, nullptr, &outputDevice->outputDevice->device) != VK_SUCCESS) {
+        return GN_FAILED;
+    }
+
+    vkGetDeviceQueue(outputDevice->outputDevice->device, indices.graphicsFamily.value(), 0, &outputDevice->outputDevice->graphicsQueue);
+    vkGetDeviceQueue(outputDevice->outputDevice->device, indices.presentFamily.value(), 0, &outputDevice->outputDevice->presentQueue);
+    outputDevice->physicalOutputDevice = const_cast<gnPhysicalOutputDevice*>(&physicalDevice);
+
+    {
+        QueueFamilyIndices queueFamilyIndices = findQueueFamilies(
+                outputDevice->physicalOutputDevice->physicalOutputDevice->instance->instance->window_surface,
+                outputDevice->physicalOutputDevice->physicalOutputDevice->device
+        );
+
+        VkCommandPoolCreateInfo poolInfo{};
+        poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+        poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+        poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
+
+        if (vkCreateCommandPool(outputDevice->outputDevice->device, &poolInfo, nullptr, &outputDevice->outputDevice->commandPool) != VK_SUCCESS) {
+            return GN_FAILED;
+        }
+    }
+
+    return GN_SUCCESS;
+}
+
+GN_EXPORT void gnWaitForDeviceFn(const gnOutputDevice& device) {
+    vkDeviceWaitIdle(device.outputDevice->device);
+}
+
+GN_EXPORT void gnDestroyOutputDeviceFn(gnOutputDevice& device) {
+    vkDestroyCommandPool(device.outputDevice->device, device.outputDevice->commandPool, nullptr);
+    vkDestroyDevice(device.outputDevice->device, nullptr);
+}

rendering_api/vulkan/src/output_device/vulkan_output_devices.h

@@ -0,0 +1,16 @@
+#pragma once
+#include <vulkan/vulkan.h>
+#include "core/output_device/gryphn_output_device.h"
+
+struct gnPlatformPhysicalOutputDevice {
+    VkPhysicalDevice device;
+    gnInstance* instance;
+};
+
+struct gnPlatformOutputDevice {
+    VkDevice device;
+    VkQueue presentQueue;
+    VkQueue graphicsQueue;
+
+    VkCommandPool commandPool;
+};

rendering_api/vulkan/src/output_device/vulkan_physical_device.cpp

@@ -0,0 +1,58 @@
+#include "core/output_device/gryphn_physical_output_device.h"
+#include <vulkan/vulkan.h>
+#include <instance/vulkan_instance.h>
+#include "presentation_queue/vulkan_queue_families.h"
+#include "vulkan_output_devices.h"
+#include "presentation_queue/vulkan_swapchain.h"
+
+// gnPhysicalOutputDevice::gnPhysicalOutputDevice() {
+//     physicalOutputDevice = new gnPlatformPhysicalOutputDevice();
+// }
+
+GN_EXPORT gnList<gnPhysicalOutputDevice> gnGetPhysicalOutputDevicesFn(const gnInstance& instance) {
+    uint32_t deviceCount = 0;
+    vkEnumeratePhysicalDevices(instance.instance->vk_instance, &deviceCount, nullptr);
+
+    if (deviceCount == 0) {
+        // throw std::runtime_error("failed to find any physical devices");
+        // TODO: why am I error checking for myself I can read the size of a list can't I
+        return gnCreateList<gnPhysicalOutputDevice>();
+    }
+
+    std::vector<VkPhysicalDevice> devices(deviceCount);
+    vkEnumeratePhysicalDevices(instance.instance->vk_instance, &deviceCount, devices.data());
+
+
+    gnList<gnPhysicalOutputDevice> outputDevices = gnCreateList<gnPhysicalOutputDevice>();
+
+    for (int i = 0; i < deviceCount; i++) {
+        gnPhysicalOutputDevice newOutputDevice = gnPhysicalOutputDevice();
+        newOutputDevice.physicalOutputDevice = new gnPlatformPhysicalOutputDevice();
+        newOutputDevice.physicalOutputDevice->device = devices[i];
+        newOutputDevice.physicalOutputDevice->instance = const_cast<gnInstance*>(&instance);
+
+        VkPhysicalDeviceProperties deviceProperties;
+        vkGetPhysicalDeviceProperties(devices[i], &deviceProperties);
+        newOutputDevice.outputDeviceName = gnCreateString(deviceProperties.deviceName);
+
+        gnListAdd(outputDevices, newOutputDevice);
+    }
+
+    return outputDevices;
+}
+
+GN_EXPORT bool gnDeviceSupportsAPIFn(const gnPhysicalOutputDevice& device) {
+    QueueFamilyIndices indices = findQueueFamilies(device.physicalOutputDevice->instance->instance->window_surface, device.physicalOutputDevice->device);
+    bool extensionsSupported = checkDeviceExtensionSupport(deviceExtensions, device.physicalOutputDevice->device);
+
+    bool swapChainAdequate = false;
+    if (extensionsSupported) {
+        SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device.physicalOutputDevice->instance->instance->window_surface, device.physicalOutputDevice->device);
+        swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
+    }
+
+    VkPhysicalDeviceFeatures supportedFeatures;
+    vkGetPhysicalDeviceFeatures(device.physicalOutputDevice->device, &supportedFeatures);
+
+    return indices.isComplete() && extensionsSupported && swapChainAdequate && supportedFeatures.samplerAnisotropy;
+}