AstralTech/Gryphn
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add queue information to Gryphn

Browse Source
This commit is contained in:
Greg Wells
2025-05-23 11:49:34 -04:00
parent 20c351e5d8
commit e7bbd9f9f2
11 changed files with 100 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
rendering_api/vulkan/src/output_device/vulkan_device_extensions.h
View File

@@ -1,8 +1,8 @@
#pragma once
#include <vulkan/vulkan.h>
#include "vector"
const std::vector<const char*> deviceExtensions = {
const uint32_t deviceExtensionCount = 2;
static const char* deviceExtensions[2] = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
"VK_KHR_portability_subset"
};

56
rendering_api/vulkan/src/output_device/vulkan_output_device.cpp
View File

@@ -12,46 +12,46 @@ GN_EXPORT gnReturnCode gnRegisterOutputDeviceFn(gnOutputDevice* outputDevice, gn
if (outputDevice->outputDevice == nullptr) outputDevice->outputDevice = new gnPlatformOutputDevice();
//instance.instance->window_surface,
QueueFamilyIndices indices = findQueueFamilies(physicalDevice.physicalDevice->device);
// QueueFamilyIndices indices = findQueueFamilies(physicalDevice.physicalDevice->device);
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
// std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
//indices.presentFamily.value()
std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value()};
// std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.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);
}
// 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;
// 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();
// 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.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
// createInfo.ppEnabledExtensionNames = deviceExtensions.data();
const char* validation_layers[1] = { "VK_LAYER_KHRONOS_validation" };
// const char* validation_layers[1] = { "VK_LAYER_KHRONOS_validation" };
createInfo.enabledLayerCount = 1;
createInfo.ppEnabledLayerNames = validation_layers;
// createInfo.enabledLayerCount = 1;
// createInfo.ppEnabledLayerNames = validation_layers;
if (vkCreateDevice(physicalDevice.physicalDevice->device, &createInfo, nullptr, &outputDevice->outputDevice->device) != VK_SUCCESS) {
return GN_FAILED_TO_CREATE_DEVICE;
}
// if (vkCreateDevice(physicalDevice.physicalDevice->device, &createInfo, nullptr, &outputDevice->outputDevice->device) != VK_SUCCESS) {
// return GN_FAILED_TO_CREATE_DEVICE;
// }
vkGetDeviceQueue(outputDevice->outputDevice->device, indices.graphicsFamily.value(), 0, &outputDevice->outputDevice->graphicsQueue);
// 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);

4
rendering_api/vulkan/src/output_device/vulkan_output_devices.h
View File

@@ -2,9 +2,9 @@
#include <vulkan/vulkan.h>
#include <core/output_device/gryphn_output_device.h>
struct gnPlatformOutputDevice {
typedef struct gnPlatformOutputDevice_t {
VkDevice device;
VkQueue presentQueue;
VkQueue graphicsQueue;
// VkCommandPool commandPool;
};
} gnPlatformOutputDevice;

43
rendering_api/vulkan/src/output_device/vulkan_physical_device.c Normal file
View File

@@ -0,0 +1,43 @@
#include "vulkan_physical_device.h"
#include <instance/vulkan_instance.h>
#include <presentation_queue/vulkan_queue_families.h>
#include <output_device/vulkan_device_extensions.h>
gnPhysicalDevice* gnGetPhysicalDevicesFn(gnInstance* instance, uint32_t* deviceCount) {
vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, NULL);
if (deviceCount == 0)
return NULL;
VkPhysicalDevice* physicalDevices = malloc(sizeof(VkPhysicalDevice) * *deviceCount);
vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, physicalDevices);
gnPhysicalDevice* outputDevices = (gnPhysicalDevice*)malloc(sizeof(gnPhysicalDevice) * *deviceCount);
for (int i = 0; i < *deviceCount; i++) {
outputDevices[i].physicalDevice = malloc(sizeof(struct gnPlatformPhysicalDevice_t));
outputDevices[i].physicalDevice->device = physicalDevices[i];
VkPhysicalDeviceProperties deviceProperties;
vkGetPhysicalDeviceProperties(physicalDevices[i], &deviceProperties);
outputDevices[i].properties.name = gnCreateString(deviceProperties.deviceName);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevices[i], &outputDevices[i].queueProperties.queueCount, NULL);
VkQueueFamilyProperties* queueFamilies = malloc(sizeof(VkQueueFamilyProperties) * outputDevices[i].queueProperties.queueCount);
outputDevices[i].queueProperties.queueProperties = malloc(sizeof(gnQueueProperties) * outputDevices[i].queueProperties.queueCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevices[i], &outputDevices[i].queueProperties.queueCount, queueFamilies);
for (int c = 0; c < outputDevices[i].queueProperties.queueCount; c++) {
outputDevices[i].queueProperties.queueProperties[i].queueCount = queueFamilies[i].queueCount;
gnQueueTypeFlags finalQueueType = 0;
if (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) finalQueueType |= GN_QUEUE_GRAPHICS;
if (queueFamilies[i].queueFlags & VK_QUEUE_COMPUTE_BIT) finalQueueType |= GN_QUEUE_COMPUTE;
if (queueFamilies[i].queueFlags & VK_QUEUE_TRANSFER_BIT) finalQueueType |= GN_QUEUE_TRANSFER;
if (queueFamilies[i].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) finalQueueType |= GN_QUEUE_SPARSE_BINDING;
outputDevices[i].queueProperties.queueProperties[i].queueType = finalQueueType;
}
}
free(physicalDevices);
return outputDevices;
}

49
rendering_api/vulkan/src/output_device/vulkan_physical_device.cpp
View File

@@ -1,49 +0,0 @@
#include "gryphn/gryphn_utils.h"
#include "vulkan_physical_device.h"
#include <instance/vulkan_instance.h>
#include <presentation_queue/vulkan_queue_families.h>
#include "vulkan_device_extensions.h"
// #include "core/output_device/gryphn_physical_output_device.h"
// #include <vulkan/vulkan.h>
// #include "vulkan_output_devices.h"
// #include "presentation_queue/vulkan_swapchain.h"
GN_EXPORT gnPhysicalDevice* gnGetPhysicalDevicesFn(gnInstance* instance, uint32_t* deviceCount) {
vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, nullptr);
if (deviceCount == 0)
return nullptr;
std::vector<VkPhysicalDevice> devices(*deviceCount);
vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, devices.data());
gnPhysicalDevice* outputDevices = (gnPhysicalDevice*)malloc(sizeof(gnPhysicalDevice) * *deviceCount);
for (int i = 0; i < *deviceCount; i++) {
outputDevices[i].physicalDevice = new gnPlatformPhysicalDevice();
outputDevices[i].physicalDevice->device = devices[i];
VkPhysicalDeviceProperties deviceProperties;
vkGetPhysicalDeviceProperties(devices[i], &deviceProperties);
outputDevices[i].name = gnCreateString(deviceProperties.deviceName);
}
return outputDevices;
}
GN_EXPORT gnBool gnDeviceSupportsAPIFn(const gnPhysicalDevice device) {
//QueueFamilyIndices indices = findQueueFamilies(device.instance->instance->window_surface, device.physicalDevice->device);
//bool swapChainAdequate = true, extensionsSupported = true;
// bool extensionsSupported = checkDeviceExtensionSupport(deviceExtensions, device.physicalDevice->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.physicalDevice->device, &supportedFeatures);
//return indices.isComplete() && extensionsSupported && swapChainAdequate && supportedFeatures.samplerAnisotropy;
return gnTrue;
}

4
rendering_api/vulkan/src/output_device/vulkan_physical_device.h
View File

@@ -2,6 +2,6 @@
#include <vulkan/vulkan.h>
#include <core/output_device/gryphn_physical_output_device.h>
struct gnPlatformPhysicalDevice {
typedef struct gnPlatformPhysicalDevice_t {
VkPhysicalDevice device;
};
} gnPlatformPhysicalDevice;

46
rendering_api/vulkan/src/presentation_queue/vulkan_queue_families.h
View File

@@ -1,46 +0,0 @@
#pragma once
#include <gryphn/gryphn_utils.h>
#include <vulkan/vulkan.h>
#include <vector>
#include "optional"
#include "set"
// quere familys shit, have zero fucking clue what this does, well I kinda do but I dont 100% know like I couldn't explain it
// it does work tho
struct QueueFamilyIndices {
std::optional<uint32_t> graphicsFamily;
// std::optional<uint32_t> presentFamily;
bool isComplete() {
return graphicsFamily.has_value(); //&& presentFamily.has_value();
}
};
static QueueFamilyIndices findQueueFamilies(const VkPhysicalDevice& device) {
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies) {
// VkBool32 presentSupport = false;
// vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
// if (presentSupport)
// indices.presentFamily = i;
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
indices.graphicsFamily = i;
if (indices.isComplete()) {
break;
}
i++;
}
return indices;
}

2
src/core/instance/init/gryphn_init.c
View File

@@ -65,8 +65,6 @@ void gnLoadFunctions(struct gnDynamicLibrary_t* lib, struct gnFunctions_t* funct
#endif
gnLoadDLLFunction(lib, functions->_gnDestroyWindowSurface, "gnDestroyWindowSurfaceFn");
printf("_gnDestroyWindowSurface location: %p\n", functions->_gnDestroyWindowSurface);
}
void gnLoadDeviceFunctions(struct gnDynamicLibrary_t* lib, struct gnDeviceFunctions_t* functions) {

4
src/core/output_device/gryphn_output_device.h
View File

@@ -1,11 +1,11 @@
#pragma once
#include <core/output_device/gryphn_physical_output_device.h>
struct gnPlatformOutputDevice;
struct gnPlatformOutputDevice_t;
struct gnDeviceFunctions_t;
typedef struct gnOutputDevice_t {
struct gnPlatformOutputDevice* outputDevice;
struct gnPlatformOutputDevice_t* outputDevice;
struct gnDeviceFunctions_t* deviceFunctions;
gnPhysicalDevice* physicalDevice;
} gnOutputDevice;

3
src/core/output_device/gryphn_physical_output_device.cpp
View File

@@ -1,3 +0,0 @@
#include "gryphn_physical_output_device.h"
gnString gnGetPhysicalOutputDeviceName(const gnPhysicalOutputDevice& device) { return device.outputDeviceName; }

26
src/core/output_device/gryphn_physical_output_device.h
View File

@@ -1,19 +1,35 @@
#pragma once
#include "core/instance/gryphn_instance.h"
struct gnPlatformPhysicalDevice;
struct gnPlatformPhysicalDevice_t;
typedef struct gnPhysicalDeviceProperties_t {
// there are currently no properties
gnString name;
} gnPhysicalDeviceProperties;
typedef enum gnQueueTypeFlags_e {
GN_QUEUE_GRAPHICS = 0x00000001,
GN_QUEUE_COMPUTE = 0x00000002,
GN_QUEUE_TRANSFER = 0x00000004,
GN_QUEUE_SPARSE_BINDING = 0x00000008
} gnQueueTypeFlags;
typedef struct gnQueueProperties_t {
uint32_t queueCount;
enum gnQueueTypeFlags_e queueType;
} gnQueueProperties;
typedef struct gnPhysicalDeviceQueueProperties_t {
uint32_t queueCount;
struct gnQueueProperties_t* queueProperties;
} gnPhysicalDeviceQueueProperties;
typedef struct gnPhysicalDevice_t {
struct gnPlatformPhysicalDevice* physicalDevice;
gnString name;
struct gnPlatformPhysicalDevice_t* physicalDevice;
struct gnPhysicalDeviceProperties_t properties;
struct gnPhysicalDeviceQueueProperties_t queueProperties;
gnInstance* instance;
} gnPhysicalDevice;
gnPhysicalDevice* gnGetPhyscialDevices(gnInstance* instance, uint32_t* count);
gnBool gnDeviceSupportsAPI(const gnPhysicalDevice device);